From e55bb5e6a62aea0d0604e9234ce2fccc092aa941 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 8 Jul 2026 16:02:25 +1000 Subject: [PATCH 1/9] fix(stack): bulk-model id split corrupts field names containing hyphens The bulk model helpers key per-field operation results by `${modelIndex}-${fieldKey}` ids and reconstructed models with a naive key.split('-'), truncating any field key containing a hyphen (some-field -> some): the value landed under the truncated key and the real field silently vanished. Duplicated across all four multi-model reconstruction sites. Extract one fieldsForModelIndex helper that splits at the FIRST hyphen only and use it at all four sites. Offline regression tests (mocked protect-ffi) prove hyphenated and multi-hyphen field names survive bulkEncryptModels / bulkDecryptModels -- both fail against the naive split. Re-expressed from james/cip-3291-bigint-stack 632bdf61. --- .../bulk-model-hyphen-fields.test.ts | 118 ++++++++++++++++++ .../src/encryption/helpers/model-helpers.ts | 69 ++++------ 2 files changed, 143 insertions(+), 44 deletions(-) create mode 100644 packages/stack/__tests__/bulk-model-hyphen-fields.test.ts diff --git a/packages/stack/__tests__/bulk-model-hyphen-fields.test.ts b/packages/stack/__tests__/bulk-model-hyphen-fields.test.ts new file mode 100644 index 00000000..9f679d94 --- /dev/null +++ b/packages/stack/__tests__/bulk-model-hyphen-fields.test.ts @@ -0,0 +1,118 @@ +/** + * Regression tests for bulk model reconstruction with hyphenated field names. + * + * The bulk model helpers key per-field operation results by a + * `${modelIndex}-${fieldKey}` id. Reconstruction previously split that id + * with a naive `split('-')`, truncating any field key containing a hyphen + * (`some-field` → `some`) — the encrypted/decrypted value then landed under + * the truncated key and the real field silently vanished from the model. + * The split now happens at the FIRST hyphen only (`fieldsForModelIndex` in + * src/encryption/helpers/model-helpers.ts). + */ + +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { EncryptionClient } from '@/encryption' +import { Encryption } from '@/index' +import { encryptedColumn, encryptedTable } from '@/schema' + +// A protect-ffi-shaped encrypted payload carrying its plaintext in `c` so +// the fake decrypt can undo it (and `isEncryptedPayload` detects it). +const enc = (plaintext: unknown) => ({ + v: 2, + i: { t: 'users', c: 'col' }, + c: `ct:${String(plaintext)}`, +}) + +vi.mock('@cipherstash/protect-ffi', () => ({ + newClient: vi.fn(async () => ({ __mock: 'client' })), + encrypt: vi.fn(async () => enc('x')), + decrypt: vi.fn(async () => 'decrypted'), + encryptBulk: vi.fn( + async (_c: unknown, opts: { plaintexts: Array<{ plaintext: unknown }> }) => + opts.plaintexts.map((p) => enc(p.plaintext)), + ), + decryptBulk: vi.fn( + async ( + _c: unknown, + opts: { ciphertexts: Array<{ ciphertext: { c: string } }> }, + ) => opts.ciphertexts.map((e) => e.ciphertext.c.replace(/^ct:/, '')), + ), + decryptBulkFallible: vi.fn( + async ( + _c: unknown, + opts: { ciphertexts: Array<{ ciphertext: { c: string } }> }, + ) => + opts.ciphertexts.map((e) => ({ + data: e.ciphertext.c.replace(/^ct:/, ''), + })), + ), + encryptQuery: vi.fn(async () => enc('x')), + encryptQueryBulk: vi.fn(async (_c: unknown, opts: { queries: unknown[] }) => + opts.queries.map(() => enc('x')), + ), +})) + +// DB column names deliberately contain hyphens — legal in (quoted) Postgres +// identifiers and previously corrupted by the naive id split. +const users = encryptedTable('users', { + 'some-field': encryptedColumn('some-field').equality(), + 'multi-part-name': encryptedColumn('multi-part-name').equality(), + plainName: encryptedColumn('plainName').equality(), +}) + +let client: EncryptionClient + +beforeEach(async () => { + vi.clearAllMocks() + client = await Encryption({ schemas: [users] }) +}) + +// biome-ignore lint/suspicious/noExplicitAny: test helper unwraps Result +function unwrap(result: any) { + if (result.failure) { + throw new Error(`operation failed: ${result.failure.message}`) + } + return result.data +} + +describe('bulk model helpers with hyphenated field names', () => { + it('bulkEncryptModels keeps hyphenated field names intact', async () => { + const models = [ + { 'some-field': 'a', 'multi-part-name': 'b', plainName: 'c', other: 1 }, + { 'some-field': 'd', plainName: 'e', other: 2 }, + ] + + const encrypted = unwrap(await client.bulkEncryptModels(models, users)) + + expect(encrypted).toHaveLength(2) + // The full hyphenated keys survive — no truncated `some` / `multi` keys. + expect(encrypted[0]['some-field']).toMatchObject({ c: 'ct:a' }) + expect(encrypted[0]['multi-part-name']).toMatchObject({ c: 'ct:b' }) + expect(encrypted[0].plainName).toMatchObject({ c: 'ct:c' }) + expect(encrypted[0]).not.toHaveProperty('some') + expect(encrypted[0]).not.toHaveProperty('multi') + expect(encrypted[0].other).toBe(1) + expect(encrypted[1]['some-field']).toMatchObject({ c: 'ct:d' }) + }) + + it('bulkDecryptModels keeps hyphenated field names intact', async () => { + const models = [ + { + 'some-field': enc('a'), + 'multi-part-name': enc('b'), + other: 1, + }, + { 'some-field': enc('c'), other: 2 }, + ] + + const decrypted = unwrap(await client.bulkDecryptModels(models)) + + expect(decrypted).toHaveLength(2) + expect(decrypted[0]['some-field']).toBe('a') + expect(decrypted[0]['multi-part-name']).toBe('b') + expect(decrypted[0]).not.toHaveProperty('some') + expect(decrypted[0]).not.toHaveProperty('multi') + expect(decrypted[0].other).toBe(1) + expect(decrypted[1]['some-field']).toBe('c') + }) +}) diff --git a/packages/stack/src/encryption/helpers/model-helpers.ts b/packages/stack/src/encryption/helpers/model-helpers.ts index 17da7dc7..1ba3997a 100644 --- a/packages/stack/src/encryption/helpers/model-helpers.ts +++ b/packages/stack/src/encryption/helpers/model-helpers.ts @@ -644,6 +644,27 @@ function prepareBulkModelsForOperation>( return { otherFields, operationFields, keyMap, nullFields } } +/** + * Collect the per-model fields out of a bulk-operation result map keyed by + * `${modelIndex}-${fieldKey}` ids, splitting each id at the FIRST hyphen + * only. Field keys may themselves contain hyphens (a `some-field` column, or + * a nested `profile.some-field` path), so a naive `split('-')` would truncate + * the field key at its first hyphen and silently drop the value during model + * reconstruction. + */ +function fieldsForModelIndex( + fields: Record, + modelIndex: number, +): Record { + const result: Record = {} + for (const [id, value] of Object.entries(fields)) { + const sep = id.indexOf('-') + if (Number.parseInt(id.slice(0, sep), 10) !== modelIndex) continue + result[id.slice(sep + 1)] = value + } + return result +} + /** * Helper function to convert multiple decrypted models to models with encrypted fields */ @@ -694,17 +715,7 @@ export async function bulkEncryptModels( } // Then, reconstruct the encrypted fields - const modelData = Object.fromEntries( - Object.entries(encryptedData) - .filter(([key]) => { - const [idx] = key.split('-') - return Number.parseInt(idx) === modelIndex - }) - .map(([key, value]) => { - const [_, fieldKey] = key.split('-') - return [fieldKey, value] - }), - ) + const modelData = fieldsForModelIndex(encryptedData, modelIndex) for (const [key, value] of Object.entries(modelData)) { const parts = key.split('.') @@ -761,17 +772,7 @@ export async function bulkDecryptModels>( } // Then, reconstruct the decrypted fields - const modelData = Object.fromEntries( - Object.entries(decryptedFields) - .filter(([key]) => { - const [idx] = key.split('-') - return Number.parseInt(idx) === modelIndex - }) - .map(([key, value]) => { - const [_, fieldKey] = key.split('-') - return [fieldKey, value] - }), - ) + const modelData = fieldsForModelIndex(decryptedFields, modelIndex) for (const [key, value] of Object.entries(modelData)) { const parts = key.split('.') @@ -833,17 +834,7 @@ export async function bulkDecryptModelsWithLockContext< } // Then, reconstruct the decrypted fields - const modelData = Object.fromEntries( - Object.entries(decryptedFields) - .filter(([key]) => { - const [idx] = key.split('-') - return Number.parseInt(idx) === modelIndex - }) - .map(([key, value]) => { - const [_, fieldKey] = key.split('-') - return [fieldKey, value] - }), - ) + const modelData = fieldsForModelIndex(decryptedFields, modelIndex) for (const [key, value] of Object.entries(modelData)) { const parts = key.split('.') @@ -907,17 +898,7 @@ export async function bulkEncryptModelsWithLockContext( } // Then, reconstruct the encrypted fields - const modelData = Object.fromEntries( - Object.entries(encryptedData) - .filter(([key]) => { - const [idx] = key.split('-') - return Number.parseInt(idx) === modelIndex - }) - .map(([key, value]) => { - const [_, fieldKey] = key.split('-') - return [fieldKey, value] - }), - ) + const modelData = fieldsForModelIndex(encryptedData, modelIndex) for (const [key, value] of Object.entries(modelData)) { const parts = key.split('.') From 66a0e026886327d77c9ce88ab891a28c019a794d Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 8 Jul 2026 16:14:01 +1000 Subject: [PATCH 2/9] feat(stack): add EQL v3 bigint domain family (i64, native JS bigint on protect-ffi 0.28) Add BIGINT/BIGINT_EQ/BIGINT_ORD_ORE/BIGINT_ORD domain definitions against the public.bigint* concrete domains, the EncryptedBigint*Column classes, types.Bigint* factories, barrel exports, and union membership, following the existing per-domain pattern. The SDK-wide Plaintext union gains bigint, and PlaintextKind/PlaintextFromKind map cast_as 'bigint' to the JS bigint type (bigint columns always decrypt to a JS bigint). Shipped UN-GATED: protect-ffi 0.28 marshals a native JS bigint across the Neon boundary losslessly (encode on the way in, JsBigInt::from_i64 on decrypt), so no reconstruction is needed on the decrypt path and the live matrix suites exercise the round-trip directly. i64 bounds are enforced at the protect-ffi boundary. Index emission follows the numeric rule: bigint_eq -> unique (hm); bigint_ord/bigint_ord_ore -> ore (equality via ob). Removes the base's bigint skip changeset and flips the schema-v3 type guard from a negative (@ts-expect-error) to a positive assertion. The catalog-driven capability sweep and live-PG matrix pick up the four public.bigint* rows automatically (no liveGate). Re-expressed from james/cip-3291-bigint-stack 2495c658 + e5934156 against the public.* domain surface and protect-ffi 0.28. --- .changeset/eql-v3-bigint-domains.md | 11 ++++ .changeset/skip-v3-bigint.md | 5 -- packages/stack/__tests__/schema-v3.test-d.ts | 9 ++- packages/stack/__tests__/schema-v3.test.ts | 5 ++ packages/stack/__tests__/v3-matrix/catalog.ts | 21 ++++++- .../__tests__/v3-matrix/matrix.test-d.ts | 5 ++ packages/stack/src/encryption/v3.ts | 6 +- packages/stack/src/eql/v3/columns.ts | 56 +++++++++++++++++-- packages/stack/src/eql/v3/index.ts | 4 ++ packages/stack/src/eql/v3/types.ts | 16 ++++++ packages/stack/src/types.ts | 20 ++++--- 11 files changed, 134 insertions(+), 24 deletions(-) create mode 100644 .changeset/eql-v3-bigint-domains.md delete mode 100644 .changeset/skip-v3-bigint.md diff --git a/.changeset/eql-v3-bigint-domains.md b/.changeset/eql-v3-bigint-domains.md new file mode 100644 index 00000000..24079583 --- /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/skip-v3-bigint.md b/.changeset/skip-v3-bigint.md deleted file mode 100644 index 481574a7..00000000 --- a/.changeset/skip-v3-bigint.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -'@cipherstash/stack': patch ---- - -Omit EQL v3 bigint factories from the public DSL and test matrix until native bigint round-tripping is supported. diff --git a/packages/stack/__tests__/schema-v3.test-d.ts b/packages/stack/__tests__/schema-v3.test-d.ts index 8eac1035..cd291102 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,9 +22,9 @@ describe('eql_v3 schema type inference', () => { expectTypeOf(col).toEqualTypeOf() }) - it('does not expose bigint factories until native bigint round-tripping lands', () => { - // @ts-expect-error - bigint v3 domains are intentionally not public yet - types.Bigint('large') + it('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', () => { @@ -65,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 @@ -75,6 +77,7 @@ describe('eql_v3 schema type inference', () => { active: boolean createdAt: Date score: number + balance: bigint }>() }) diff --git a/packages/stack/__tests__/schema-v3.test.ts b/packages/stack/__tests__/schema-v3.test.ts index fcb1db8f..18d9fa61 100644 --- a/packages/stack/__tests__/schema-v3.test.ts +++ b/packages/stack/__tests__/schema-v3.test.ts @@ -170,6 +170,11 @@ describe('eql_v3 concrete type names', () => { ) expect(types.SmallintOrd('n').getEqlType()).toBe('public.smallint_ord') + expect(types.Bigint('n').getEqlType()).toBe('public.bigint') + expect(types.BigintEq('n').getEqlType()).toBe('public.bigint_eq') + expect(types.BigintOrdOre('n').getEqlType()).toBe('public.bigint_ord_ore') + expect(types.BigintOrd('n').getEqlType()).toBe('public.bigint_ord') + expect(types.Boolean('b').getEqlType()).toBe('public.boolean') expect(types.Real('n').getEqlType()).toBe('public.real') expect(types.RealEq('n').getEqlType()).toBe('public.real_eq') diff --git a/packages/stack/__tests__/v3-matrix/catalog.ts b/packages/stack/__tests__/v3-matrix/catalog.ts index d0bd8d22..b08e8686 100644 --- a/packages/stack/__tests__/v3-matrix/catalog.ts +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -23,6 +23,10 @@ import type { QueryCapabilities, } from '@/eql/v3' import { + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, @@ -99,7 +103,7 @@ 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. @@ -175,6 +179,16 @@ 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 (enforced at the protect-ffi boundary): 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. +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 @@ -220,6 +234,11 @@ export const V3_MATRIX = { 'public.smallint_eq': { builder: types.SmallintEq, ColumnClass: EncryptedSmallintEqColumn, castAs: 'number', capabilities: EQ, indexes: UNIQUE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, 'public.smallint_ord_ore': { builder: types.SmallintOrdOre, ColumnClass: EncryptedSmallintOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, 'public.smallint_ord': { builder: types.SmallintOrd, ColumnClass: EncryptedSmallintOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, + // bigint (int8) — native JS bigint round-trip on protect-ffi 0.28; ungated + 'public.bigint': { builder: types.Bigint, ColumnClass: EncryptedBigintColumn, castAs: 'bigint', capabilities: STORAGE, indexes: NONE, samples: BIGINT_S }, + 'public.bigint_eq': { builder: types.BigintEq, ColumnClass: EncryptedBigintEqColumn, castAs: 'bigint', capabilities: EQ, indexes: UNIQUE_IDX, samples: BIGINT_S }, + 'public.bigint_ord_ore': { builder: types.BigintOrdOre, ColumnClass: EncryptedBigintOrdOreColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S }, + 'public.bigint_ord': { builder: types.BigintOrd, ColumnClass: EncryptedBigintOrdColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S }, // date 'public.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, 'public.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, diff --git a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts index 02bfdbd0..435245c1 100644 --- a/packages/stack/__tests__/v3-matrix/matrix.test-d.ts +++ b/packages/stack/__tests__/v3-matrix/matrix.test-d.ts @@ -25,6 +25,7 @@ const records = encryptedTable('records', { count: V3_MATRIX['public.integer'].builder('count'), // number, storage-only score: V3_MATRIX['public.integer_eq'].builder('score'), // number, equality rank: V3_MATRIX['public.integer_ord'].builder('rank'), // number, order + range + balance: V3_MATRIX['public.bigint_ord'].builder('balance'), // bigint, order + range createdAt: V3_MATRIX['public.timestamp_ord'].builder('created_at'), // date email: V3_MATRIX['public.text_search'].builder('email'), // string, full-text active: V3_MATRIX['public.boolean'].builder('active'), // boolean, storage-only @@ -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' >() diff --git a/packages/stack/src/encryption/v3.ts b/packages/stack/src/encryption/v3.ts index eb45bd96..29be610a 100644 --- a/packages/stack/src/encryption/v3.ts +++ b/packages/stack/src/encryption/v3.ts @@ -128,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` (int8) reconstruction is intentionally absent — int8 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, diff --git a/packages/stack/src/eql/v3/columns.ts b/packages/stack/src/eql/v3/columns.ts index a5e75a61..77329211 100644 --- a/packages/stack/src/eql/v3/columns.ts +++ b/packages/stack/src/eql/v3/columns.ts @@ -40,7 +40,7 @@ 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' | DateLikeCast +type PlaintextKind = 'string' | 'number' | 'bigint' | 'boolean' | DateLikeCast /** * The full, literal definition of a v3 domain. This is the LOAD-BEARING type: @@ -152,6 +152,31 @@ export const SMALLINT_ORD = { capabilities: ORDER_AND_RANGE, } as const +// bigint (int8) domains. Plaintext is a JS `bigint` (always decrypts to +// `bigint`); bounds are the full i64 range, enforced at the protect-ffi +// boundary, which round-trips a native bigint losslessly. (`*_ord_ope` +// variants are out of scope — CIP-3403.) +export const BIGINT = { + eqlType: 'public.bigint', + castAs: 'bigint', + capabilities: STORAGE_ONLY, +} as const +export const BIGINT_EQ = { + eqlType: 'public.bigint_eq', + castAs: 'bigint', + capabilities: EQUALITY_ONLY, +} as const +export const BIGINT_ORD_ORE = { + eqlType: 'public.bigint_ord_ore', + castAs: 'bigint', + capabilities: ORDER_AND_RANGE, +} as const +export const BIGINT_ORD = { + eqlType: 'public.bigint_ord', + castAs: 'bigint', + capabilities: ORDER_AND_RANGE, +} as const + export const DATE = { eqlType: 'public.date', castAs: 'date', @@ -497,6 +522,19 @@ export class EncryptedSmallintOrdColumn extends EncryptedV3Column< typeof SMALLINT_ORD > {} +// 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 {} export class EncryptedDateEqColumn extends EncryptedV3Column {} @@ -584,6 +622,10 @@ export type AnyEncryptedV3Column = | EncryptedSmallintEqColumn | EncryptedSmallintOrdOreColumn | EncryptedSmallintOrdColumn + | EncryptedBigintColumn + | EncryptedBigintEqColumn + | EncryptedBigintOrdOreColumn + | EncryptedBigintOrdColumn | EncryptedDateColumn | EncryptedDateEqColumn | EncryptedDateOrdOreColumn @@ -625,11 +667,13 @@ type PlaintextFromKind = K extends 'string' ? string : K extends 'number' ? number - : K extends 'boolean' - ? boolean - : K extends DateLikeCast - ? 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/index.ts b/packages/stack/src/eql/v3/index.ts index 31702c59..069dc7ad 100644 --- a/packages/stack/src/eql/v3/index.ts +++ b/packages/stack/src/eql/v3/index.ts @@ -18,6 +18,10 @@ export type { } from './columns' export { + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, diff --git a/packages/stack/src/eql/v3/types.ts b/packages/stack/src/eql/v3/types.ts index 4fcd3b4e..2ae0a1c7 100644 --- a/packages/stack/src/eql/v3/types.ts +++ b/packages/stack/src/eql/v3/types.ts @@ -1,4 +1,8 @@ import { + BIGINT, + BIGINT_EQ, + BIGINT_ORD, + BIGINT_ORD_ORE, BOOLEAN, DATE, DATE_EQ, @@ -8,6 +12,10 @@ import { DOUBLE_EQ, DOUBLE_ORD, DOUBLE_ORD_ORE, + EncryptedBigintColumn, + EncryptedBigintEqColumn, + EncryptedBigintOrdColumn, + EncryptedBigintOrdOreColumn, EncryptedBooleanColumn, EncryptedDateColumn, EncryptedDateEqColumn, @@ -117,6 +125,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), diff --git a/packages/stack/src/types.ts b/packages/stack/src/types.ts index 5a3cca00..f6cc5502 100644 --- a/packages/stack/src/types.ts +++ b/packages/stack/src/types.ts @@ -72,15 +72,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. * - * When the upstream FFI `JsPlaintext` includes `Date`, this extra arm can - * collapse back into `JsPlaintext`. + * `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` 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 From 0b9b192d0846ba4b911898a6d576c511eadc64dc Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 8 Jul 2026 16:35:45 +1000 Subject: [PATCH 3/9] feat(cli): EQL v3 install path (--eql-version) + rename db install to eql install MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Vendor the v3 SQL bundles into packages/cli/src/sql via a checked-in derivation script (scripts/build-eql-v3-sql.mjs): the full bundle is a byte-identical copy of the stack public.* fixture monolith; the Supabase variant strips the two CREATE OPERATOR CLASS/FAMILY chunks at their --! @file markers (they need superuser). EQLInstaller gains an eqlVersion option on install/isInstalled/ getInstalledVersion; v3 keys install-detection, version(), and Supabase grants to the eql_v3 schema (type domains live in public, operators in eql_v3, constructors in eql_v3_internal). v3 + --latest is rejected (no public artifacts). eql install --eql-version 3 is direct-install only — --drizzle/--migration/--migrations-dir/--latest are rejected up front and auto-detected drizzle falls back to direct with a notice. Move db install under a dedicated eql command group as eql install; db install stays as a deprecated alias that warns and forwards. Help text, next-step hints, generated Supabase migration headers, wizard allowlist + steps, docs, and tests all reference eql install. Re-expressed from james/cip-3291-bigint-stack d15414a5 + e027b749 + 64fdeb2c against the public.* v3 bundle (scoped to the install rename; the eqlVersion runtime client flag and eql upgrade/status moves are intentionally not ported). --- .changeset/eql-v3-cli-install.md | 13 + .../rename-db-install-to-eql-install.md | 11 + e2e/tests/package-managers.e2e.test.ts | 16 +- packages/cli/AGENTS.md | 2 +- packages/cli/README.md | 20 +- packages/cli/scripts/build-eql-v3-sql.mjs | 81 + packages/cli/src/__tests__/installer.test.ts | 85 + .../src/__tests__/supabase-migration.test.ts | 47 +- packages/cli/src/bin/main.ts | 88 +- .../cli/src/commands/db/client-scaffold.ts | 4 +- .../cli/src/commands/db/config-scaffold.ts | 2 +- packages/cli/src/commands/db/detect.ts | 2 +- packages/cli/src/commands/db/install.ts | 66 +- packages/cli/src/commands/db/status.ts | 2 +- .../cli/src/commands/db/supabase-migration.ts | 2 +- packages/cli/src/commands/db/upgrade.ts | 2 +- .../src/commands/encrypt/drizzle-helper.ts | 2 +- .../src/commands/init/__tests__/utils.test.ts | 4 +- .../commands/init/doctrine/AGENTS-doctrine.md | 2 +- .../cli/src/commands/init/lib/setup-prompt.ts | 2 +- .../init/providers/__tests__/base.test.ts | 8 +- .../init/providers/__tests__/drizzle.test.ts | 8 +- .../providers/__tests__/prisma-next.test.ts | 6 +- .../init/providers/__tests__/supabase.test.ts | 8 +- .../cli/src/commands/init/providers/base.ts | 2 +- .../src/commands/init/providers/drizzle.ts | 2 +- .../commands/init/providers/prisma-next.ts | 2 +- .../src/commands/init/providers/supabase.ts | 2 +- .../src/commands/init/steps/build-schema.ts | 2 +- .../src/commands/init/steps/install-deps.ts | 2 +- .../src/commands/init/steps/install-eql.ts | 10 +- packages/cli/src/commands/init/utils.ts | 2 +- packages/cli/src/installer/index.ts | 115 +- packages/cli/src/messages.ts | 6 + .../sql/cipherstash-encrypt-v3-supabase.sql | 43251 +++++++++++++++ .../cli/src/sql/cipherstash-encrypt-v3.sql | 43339 ++++++++++++++++ .../tests/e2e/runner-aware-help.e2e.test.ts | 2 +- packages/cli/tests/e2e/smoke.e2e.test.ts | 2 +- packages/wizard/README.md | 6 +- .../wizard/src/__tests__/post-agent.test.ts | 8 +- .../src/__tests__/prerequisites.test.ts | 2 +- .../src/agent/__tests__/interface.test.ts | 14 +- packages/wizard/src/agent/interface.ts | 8 +- packages/wizard/src/lib/post-agent.ts | 10 +- packages/wizard/src/lib/prerequisites.ts | 2 +- packages/wizard/src/lib/rewrite-migrations.ts | 2 +- packages/wizard/src/run.ts | 2 +- 47 files changed, 87128 insertions(+), 148 deletions(-) create mode 100644 .changeset/eql-v3-cli-install.md create mode 100644 .changeset/rename-db-install-to-eql-install.md create mode 100644 packages/cli/scripts/build-eql-v3-sql.mjs create mode 100644 packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql create mode 100644 packages/cli/src/sql/cipherstash-encrypt-v3.sql diff --git a/.changeset/eql-v3-cli-install.md b/.changeset/eql-v3-cli-install.md new file mode 100644 index 00000000..68f88e44 --- /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/rename-db-install-to-eql-install.md b/.changeset/rename-db-install-to-eql-install.md new file mode 100644 index 00000000..3c1a2b1a --- /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/e2e/tests/package-managers.e2e.test.ts b/e2e/tests/package-managers.e2e.test.ts index d6b788b2..85f65414 100644 --- a/e2e/tests/package-managers.e2e.test.ts +++ b/e2e/tests/package-managers.e2e.test.ts @@ -51,18 +51,18 @@ describe('CLI init providers — package-manager-aware Next Steps', () => { { label: 'base', create: createBaseProvider, - firstStep: (r) => `Set up your database: ${r} stash db install`, + firstStep: (r) => `Set up your database: ${r} stash eql install`, }, { label: 'drizzle', create: createDrizzleProvider, - firstStep: (r) => `Set up your database: ${r} stash db install --drizzle`, + firstStep: (r) => `Set up your database: ${r} stash eql install --drizzle`, }, { label: 'supabase', create: createSupabaseProvider, firstStep: (r) => - `Install EQL: ${r} stash db install --supabase (prompts for migration vs direct)`, + `Install EQL: ${r} stash eql install --supabase (prompts for migration vs direct)`, }, ] @@ -158,12 +158,12 @@ describe.skipIf(!authConfigured)( { pm: 'yarn' as const, lockfile: 'yarn.lock' }, ])('uses $pm runner when $lockfile is present', ({ pm, lockfile }) => { const out = runWizard({ lockfile }) - expect(out).toContain(`Run: ${RUNNER[pm]} stash db install`) + expect(out).toContain(`Run: ${RUNNER[pm]} stash eql install`) }) it('falls back to npx when no lockfile and no user agent', () => { const out = runWizard({}) - expect(out).toContain('Run: npx stash db install') + expect(out).toContain('Run: npx stash eql install') }) }) @@ -174,7 +174,7 @@ describe.skipIf(!authConfigured)( { pm: 'yarn' as const, userAgent: 'yarn/4.0.0 npm/? node/v20.0.0' }, ])('uses $pm runner when UA is $userAgent', ({ pm, userAgent }) => { const out = runWizard({ userAgent }) - expect(out).toContain(`Run: ${RUNNER[pm]} stash db install`) + expect(out).toContain(`Run: ${RUNNER[pm]} stash eql install`) }) }) @@ -184,7 +184,7 @@ describe.skipIf(!authConfigured)( lockfile: 'pnpm-lock.yaml', userAgent: 'bun/1.1.40 npm/? node/v22.3.0', }) - expect(out).toContain('Run: bunx stash db install') + expect(out).toContain('Run: bunx stash eql install') }) it('npm user agent is ignored in favour of a lockfile', () => { @@ -192,7 +192,7 @@ describe.skipIf(!authConfigured)( lockfile: 'bun.lock', userAgent: 'npm/10.2.4 node/v20.0.0', }) - expect(out).toContain('Run: bunx stash db install') + expect(out).toContain('Run: bunx stash eql install') }) }) }, diff --git a/packages/cli/AGENTS.md b/packages/cli/AGENTS.md index 5efd2a7b..c4dc360f 100644 --- a/packages/cli/AGENTS.md +++ b/packages/cli/AGENTS.md @@ -71,7 +71,7 @@ exercise the same code paths. tweak only needs to land in one place. Add to `messages.ts` only when a test actually asserts on the string — premature extraction is worse than copy-paste here. For literals tests don't touch (e.g. command - names like `init`, `db install`), keep them inline. + names like `init`, `eql install`), keep them inline. - **Telemetry.** The CLI source no longer imports `posthog-node` (analytics moved to `packages/wizard`). The dep is still listed in `package.json` and should be removed in a follow-up. If you re-introduce telemetry to diff --git a/packages/cli/README.md b/packages/cli/README.md index ba63754f..3349f10f 100644 --- a/packages/cli/README.md +++ b/packages/cli/README.md @@ -61,7 +61,7 @@ export default defineConfig({ The CLI loads `.env` files automatically before reading the config, so `process.env` references work without extra setup. The config file is resolved by walking up from the current working directory. -Commands that consume `stash.config.ts`: `db install`, `db upgrade`, `db push`, `db validate`, `db status`, `db test-connection`, `schema build`. `db install` will scaffold `stash.config.ts` for you if it's missing. +Commands that consume `stash.config.ts`: `eql install`, `db upgrade`, `db push`, `db validate`, `db status`, `db test-connection`, `schema build`. `eql install` will scaffold `stash.config.ts` for you if it's missing. --- @@ -83,10 +83,10 @@ npx stash init [--supabase] [--drizzle] What `init` does, in order: 1. **Authenticate** — re-uses an existing token if found, otherwise opens the browser device-code flow. -2. **Resolve `DATABASE_URL`** — flag → env → `supabase status` → interactive prompt → hard-fail. The same resolver `db install` uses. +2. **Resolve `DATABASE_URL`** — flag → env → `supabase status` → interactive prompt → hard-fail. The same resolver `eql install` uses. 3. **Generate the encryption client** — connects to your database, lists tables, and prompts you to multi-select which columns to encrypt. Writes `./src/encryption/index.ts` with the right shape for the detected ORM (Drizzle / Supabase / plain Postgres). Falls back to a placeholder if the database has no tables yet. 4. **Install dependencies** — `@cipherstash/stack` (runtime) and `stash` (dev), with a confirmation prompt. -5. **Install EQL** — runs `stash db install` against the resolved URL after a y/N confirm. +5. **Install EQL** — runs `stash eql install` against the resolved URL after a y/N confirm. 6. **Hand off** — four-option menu (Claude Code / Codex / CipherStash Agent / write `AGENTS.md`). See the Quickstart section above for what each option writes and spawns. The full pipeline state — integration, columns, env-key names, paths, versions — is captured in `.cipherstash/context.json`. The action plan at `.cipherstash/setup-prompt.md` tells whichever agent picks up next what's already done and what's left. @@ -156,14 +156,14 @@ npx stash secrets delete -n DATABASE_URL -e production -y --- -### `npx stash db install` +### `npx stash eql install` -Configure your database and install CipherStash EQL extensions in a single command. Run this after `npx stash init`. +Configure your database and install CipherStash EQL extensions in a single command. Run this after `npx stash init`. (`npx stash db install` is a deprecated alias — it still works but prints a warning.) When `stash.config.ts` is missing, the command auto-detects your encryption client file (or asks for the path) and writes the config before installing. Supabase and Drizzle are detected from your `DATABASE_URL` and project files, so the matching flags default on. Install uses bundled SQL for offline, deterministic runs. ```bash -npx stash db install [options] +npx stash eql install [options] ``` | Flag | Description | @@ -198,7 +198,7 @@ npx stash db upgrade [options] | `--exclude-operator-family` | Skip operator family creation | | `--latest` | Fetch the latest EQL from GitHub | -The install SQL is idempotent and safe to re-run. If EQL is not installed, the command suggests running `npx stash db install` instead. +The install SQL is idempotent and safe to re-run. If EQL is not installed, the command suggests running `npx stash eql install` instead. --- @@ -300,10 +300,10 @@ Reads `databaseUrl` from `stash.config.ts`. ## Drizzle migration mode -Use `--drizzle` with `npx stash db install` to add EQL installation to your Drizzle migration history instead of applying it directly. `--drizzle` is auto-detected when your project has `drizzle-orm`, `drizzle-kit`, or a `drizzle.config.*` file, so you usually don't need to pass it explicitly. +Use `--drizzle` with `npx stash eql install` to add EQL installation to your Drizzle migration history instead of applying it directly. `--drizzle` is auto-detected when your project has `drizzle-orm`, `drizzle-kit`, or a `drizzle.config.*` file, so you usually don't need to pass it explicitly. ```bash -npx stash db install --drizzle +npx stash eql install --drizzle npx drizzle-kit migrate ``` @@ -315,7 +315,7 @@ How it works: With a custom name or output directory: ```bash -npx stash db install --drizzle --name setup-eql --out ./migrations +npx stash eql install --drizzle --name setup-eql --out ./migrations npx drizzle-kit migrate ``` diff --git a/packages/cli/scripts/build-eql-v3-sql.mjs b/packages/cli/scripts/build-eql-v3-sql.mjs new file mode 100644 index 00000000..9adbe61c --- /dev/null +++ b/packages/cli/scripts/build-eql-v3-sql.mjs @@ -0,0 +1,81 @@ +#!/usr/bin/env node +/** + * Vendor the EQL v3 SQL bundles into packages/cli/src/sql/. + * + * Source of truth: the generated monolith checked in at + * packages/stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql + * (itself generated from the upstream encrypt-query-language repo). + * + * Outputs: + * - cipherstash-encrypt-v3.sql — full bundle, byte-identical copy + * - cipherstash-encrypt-v3-supabase.sql — Supabase variant with the two + * `CREATE OPERATOR CLASS`/`FAMILY` chunks removed (they need superuser, + * which Supabase does not grant) + * + * The Supabase 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. + * + * TEMPORARY vendoring strategy (sync risk): once upstream publishes v3 release + * artifacts (like the eql-2.x `cipherstash-encrypt[-supabase].sql` assets), + * regenerate these from the release instead and record the version. + * + * Usage: node packages/cli/scripts/build-eql-v3-sql.mjs + */ +import { readFileSync, writeFileSync } from 'node:fs' +import { dirname, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' + +const here = dirname(fileURLToPath(import.meta.url)) +const source = resolve( + here, + '../../stack/__tests__/fixtures/eql-v3/cipherstash-encrypt-v3.sql', +) +const outDir = resolve(here, '../src/sql') + +const FILE_MARKER = /^--! @file (.+)$/ +const EXCLUDE = /operator_class\.sql$/ + +function stripOperatorClassChunks(sql) { + const lines = sql.split('\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) + } + + if (removedChunks !== 2) { + throw new Error( + `Expected to remove exactly 2 operator_class chunks, removed ${removedChunks} — the bundle layout changed; review the strip logic.`, + ) + } + + const stripped = out.join('\n') + if (/CREATE OPERATOR (CLASS|FAMILY)/.test(stripped)) { + throw new Error( + 'Stripped bundle still contains CREATE OPERATOR CLASS/FAMILY statements.', + ) + } + + return stripped +} + +const sql = readFileSync(source, 'utf8') + +writeFileSync(resolve(outDir, 'cipherstash-encrypt-v3.sql'), sql) +writeFileSync( + resolve(outDir, 'cipherstash-encrypt-v3-supabase.sql'), + stripOperatorClassChunks(sql), +) + +console.log( + 'Wrote cipherstash-encrypt-v3.sql and cipherstash-encrypt-v3-supabase.sql', +) diff --git a/packages/cli/src/__tests__/installer.test.ts b/packages/cli/src/__tests__/installer.test.ts index 2c0e0bb5..cef478be 100644 --- a/packages/cli/src/__tests__/installer.test.ts +++ b/packages/cli/src/__tests__/installer.test.ts @@ -204,6 +204,91 @@ describe('EQLInstaller', () => { expect(SUPABASE_PERMISSIONS_SQL).toContain('service_role') }) + it('installs the v3 bundle and grants eql_v3 permissions with eqlVersion: 3 + supabase', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller, SUPABASE_PERMISSIONS_SQL_V3 } = await import( + '@/installer/index.ts' + ) + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.install({ eqlVersion: 3, supabase: true }) + + const otherCalls = mockQuery.mock.calls + .map((call: unknown[]) => call[0]) + .filter( + (sql: unknown): sql is string => + typeof sql === 'string' && + sql !== 'BEGIN' && + sql !== 'COMMIT' && + sql !== 'ROLLBACK', + ) + + expect(otherCalls).toHaveLength(2) + // The bundled SQL is the v3 Supabase variant: creates eql_v3, no + // operator classes/families (they need superuser). + expect(otherCalls[0]).toContain('eql_v3') + expect(otherCalls[0]).not.toContain('CREATE OPERATOR CLASS') + expect(otherCalls[0]).not.toContain('CREATE OPERATOR FAMILY') + // The grants are keyed to eql_v3, not eql_v2. + expect(otherCalls[1]).toBe(SUPABASE_PERMISSIONS_SQL_V3) + expect(SUPABASE_PERMISSIONS_SQL_V3).toContain('eql_v3') + expect(SUPABASE_PERMISSIONS_SQL_V3).not.toContain('eql_v2') + }) + + it('installs the full v3 bundle (with operator classes) without supabase', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.install({ eqlVersion: 3 }) + + const sqlCall = mockQuery.mock.calls.find( + (call: string[]) => + typeof call[0] === 'string' && + call[0] !== 'BEGIN' && + call[0] !== 'COMMIT', + ) + expect(sqlCall).toBeDefined() + expect(sqlCall?.[0]).toContain('eql_v3') + expect(sqlCall?.[0]).toContain('CREATE OPERATOR CLASS') + }) + + it('rejects latest: true for eqlVersion: 3', async () => { + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await expect( + installer.install({ eqlVersion: 3, latest: true }), + ).rejects.toThrow('not supported for EQL v3') + }) + + it('checks the eql_v3 schema for isInstalled({ eqlVersion: 3 })', async () => { + mockConnect.mockResolvedValue(undefined) + mockQuery.mockResolvedValue({ rows: [], rowCount: 0 }) + mockEnd.mockResolvedValue(undefined) + + const { EQLInstaller } = await import('@/installer/index.ts') + const installer = new EQLInstaller({ + databaseUrl: 'postgresql://localhost:5432/test', + }) + + await installer.isInstalled({ eqlVersion: 3 }) + + expect(mockQuery).toHaveBeenCalledWith(expect.any(String), ['eql_v3']) + }) + it('rolls back on SQL execution failure', async () => { mockConnect.mockResolvedValue(undefined) mockEnd.mockResolvedValue(undefined) diff --git a/packages/cli/src/__tests__/supabase-migration.test.ts b/packages/cli/src/__tests__/supabase-migration.test.ts index ea3b0955..1e6b60a0 100644 --- a/packages/cli/src/__tests__/supabase-migration.test.ts +++ b/packages/cli/src/__tests__/supabase-migration.test.ts @@ -18,7 +18,7 @@ import { SUPABASE_PERMISSIONS_SQL } from '../installer/index.js' * Mirrors the production function but imported for testing. */ function migrationHeader(runner: string): string { - return `-- CipherStash EQL — installed by \`${runner} stash db install --supabase --migration\`. + return `-- CipherStash EQL — installed by \`${runner} stash eql install --supabase --migration\`. -- -- This migration installs the CipherStash Encrypt Query Language (EQL) types, -- functions, and operators into the \`eql_v2\` schema, then grants Supabase's @@ -136,7 +136,7 @@ describe('writeSupabaseEqlMigration', () => { const contents = fs.readFileSync(result.path, 'utf-8') // Header comment block includes the detected runner instruction expect(contents).toMatch( - /-- CipherStash EQL — installed by `(npx|bunx|pnpm dlx|yarn dlx) stash db install --supabase --migration`/, + /-- CipherStash EQL — installed by `(npx|bunx|pnpm dlx|yarn dlx) stash eql install --supabase --migration`/, ) expect(contents).toContain('CipherStash') // EQL SQL body — the bundled supabase variant defines eql_v2. @@ -242,6 +242,43 @@ describe('validateInstallFlags', () => { expect(err).toMatch(/mutually exclusive/i) }) + it('accepts --eql-version 2 and 3', () => { + expect(validateInstallFlags({ eqlVersion: '2' })).toBeNull() + expect(validateInstallFlags({ eqlVersion: '3' })).toBeNull() + expect( + validateInstallFlags({ eqlVersion: '3', supabase: true, direct: true }), + ).toBeNull() + }) + + it('rejects an unknown --eql-version value', () => { + expect(validateInstallFlags({ eqlVersion: '4' })).toMatch(/--eql-version/) + }) + + it('rejects --eql-version 3 with --drizzle, --migration, --latest, or --migrations-dir', () => { + expect(validateInstallFlags({ eqlVersion: '3', drizzle: true })).toMatch( + /--drizzle/, + ) + expect( + validateInstallFlags({ + eqlVersion: '3', + supabase: true, + migration: true, + }), + ).toMatch(/--migration/) + expect(validateInstallFlags({ eqlVersion: '3', latest: true })).toMatch( + /--latest/, + ) + // --migrations-dir only feeds the v2 Supabase migration-file path; the v3 + // direct install would silently ignore it (flagged in review of #547). + expect( + validateInstallFlags({ + eqlVersion: '3', + supabase: true, + migrationsDir: 'db/migrations', + }), + ).toMatch(/--migrations-dir/) + }) + it('does NOT auto-imply --supabase from --migration', () => { // Even with --supabase: false explicitly, --migration must error. const err = validateInstallFlags({ supabase: false, migration: true }) @@ -253,18 +290,18 @@ describe('migrationHeader', () => { it('renders the header with the provided runner for npx', () => { const header = migrationHeader('npx') expect(header).toContain( - '-- CipherStash EQL — installed by `npx stash db install --supabase --migration`.', + '-- CipherStash EQL — installed by `npx stash eql install --supabase --migration`.', ) }) it('renders the header with the provided runner for bunx', () => { const header = migrationHeader('bunx') - expect(header).toContain('bunx stash db install') + expect(header).toContain('bunx stash eql install') }) it('renders the header with the provided runner for pnpm dlx', () => { const header = migrationHeader('pnpm dlx') - expect(header).toContain('pnpm dlx stash db install') + expect(header).toContain('pnpm dlx stash eql install') }) it('includes all expected documentation lines', () => { diff --git a/packages/cli/src/bin/main.ts b/packages/cli/src/bin/main.ts index c9cbbc27..ca203ed3 100644 --- a/packages/cli/src/bin/main.ts +++ b/packages/cli/src/bin/main.ts @@ -90,7 +90,8 @@ Commands: wizard AI-guided encryption setup (reads your codebase) doctor Diagnose install problems (native binaries, runtime) - db install Scaffold stash.config.ts (if missing) and install EQL extensions + eql install Scaffold stash.config.ts (if missing) and install EQL extensions + db upgrade Upgrade EQL extensions to the latest version db push Push encryption schema (writes pending if active config already exists) db activate Promote pending → active without renames (use after additive db push) @@ -146,17 +147,19 @@ Impl Flags: non-TTY contexts (CI, pipes). Without --target in non-TTY, the command prints a hint and exits cleanly instead of hanging. -DB Flags: - --force (install) Reinstall / overwrite even if already installed - --dry-run (install, push, upgrade) Show what would happen without making changes - --supabase (install, upgrade, validate) Use Supabase-compatible mode (auto-detected from DATABASE_URL) - --drizzle (install) Generate a Drizzle migration instead of direct install (auto-detected from project) - --migration (install, requires --supabase) Write a Supabase migration file instead of running SQL directly - --direct (install, requires --supabase) Run the SQL directly against the database (mutually exclusive with --migration) - --migrations-dir (install, requires --supabase) Override the Supabase migrations directory (default: supabase/migrations) - --exclude-operator-family (install, upgrade, validate) Skip operator family creation - --latest (install, upgrade) Fetch the latest EQL from GitHub - --database-url (all db / schema commands) Override DATABASE_URL for this run only — never written to disk +DB / EQL Flags: + --force (eql install) Reinstall / overwrite even if already installed + --dry-run (eql install, db push, db upgrade) Show what would happen without making changes + --supabase (eql install, db upgrade, db validate) Use Supabase-compatible mode (auto-detected from DATABASE_URL) + --drizzle (eql install) Generate a Drizzle migration instead of direct install (auto-detected from project) + --migration (eql install, requires --supabase) Write a Supabase migration file instead of running SQL directly + --direct (eql install, requires --supabase) Run the SQL directly against the database (mutually exclusive with --migration) + --migrations-dir (eql install, requires --supabase) Override the Supabase migrations directory (default: supabase/migrations) + --exclude-operator-family (eql install, db upgrade, db validate) Skip operator family creation + --eql-version <2|3> (eql install) EQL generation to install (default: 2). v3 installs the native + concrete-domain schema (public.* type domains); direct install only for now + --latest (eql install, db upgrade) Fetch the latest EQL from GitHub (v2 only) + --database-url (all db / eql / schema commands) Override DATABASE_URL for this run only — never written to disk Examples: ${STASH} init @@ -169,7 +172,7 @@ Examples: ${STASH} status ${STASH} auth login ${STASH} wizard - ${STASH} db install + ${STASH} eql install ${STASH} db push ${STASH} schema build ${STASH} doctor @@ -212,6 +215,44 @@ function parseArgs(argv: string[]): ParsedArgs { return { command, subcommand, commandArgs, flags, values } } +async function runInstall( + flags: Record, + values: Record, +) { + await installCommand({ + force: flags.force, + dryRun: flags['dry-run'], + supabase: flags.supabase, + excludeOperatorFamily: flags['exclude-operator-family'], + drizzle: flags.drizzle, + latest: flags.latest, + name: values.name, + out: values.out, + migration: flags.migration, + direct: flags.direct, + migrationsDir: values['migrations-dir'], + eqlVersion: values['eql-version'], + databaseUrl: values['database-url'], + }) +} + +async function runEqlCommand( + sub: string | undefined, + flags: Record, + values: Record, +) { + switch (sub) { + case 'install': + await runInstall(flags, values) + break + default: + p.log.error(`${messages.eql.unknownSubcommand}: ${sub ?? '(none)'}`) + console.log() + console.log(HELP) + process.exit(1) + } +} + async function runDbCommand( sub: string | undefined, flags: Record, @@ -223,20 +264,10 @@ async function runDbCommand( switch (sub) { case 'install': - await installCommand({ - force: flags.force, - dryRun: flags['dry-run'], - supabase: flags.supabase, - excludeOperatorFamily: flags['exclude-operator-family'], - drizzle: flags.drizzle, - latest: flags.latest, - name: values.name, - out: values.out, - migration: flags.migration, - direct: flags.direct, - migrationsDir: values['migrations-dir'], - databaseUrl, - }) + // Deprecated alias — the command moved to `eql install`. Keep the old + // spelling working so existing scripts and published docs don't break. + p.log.warn(messages.db.installDeprecated(STASH)) + await runInstall(flags, values) break case 'upgrade': await upgradeCommand({ @@ -437,6 +468,9 @@ export async function run() { await authCommand(authArgs, flags) break } + case 'eql': + await runEqlCommand(subcommand, flags, values) + break case 'db': await runDbCommand(subcommand, flags, values) break diff --git a/packages/cli/src/commands/db/client-scaffold.ts b/packages/cli/src/commands/db/client-scaffold.ts index d04e26e2..5e438599 100644 --- a/packages/cli/src/commands/db/client-scaffold.ts +++ b/packages/cli/src/commands/db/client-scaffold.ts @@ -6,7 +6,7 @@ import { generatePlaceholderClient } from '../init/utils.js' import { detectDrizzle, detectSupabase } from './detect.js' /** - * Pick a placeholder template using the same signals `db install` already + * Pick a placeholder template using the same signals `eql install` already * detects. Drizzle wins over Supabase when both look present (a Drizzle-on- * Supabase project is more naturally scaffolded as Drizzle). */ @@ -25,7 +25,7 @@ function detectIntegration( * * `init`'s `buildSchemaStep` is the primary path that creates this file * (and handles the "file already exists" case interactively). This function - * exists as a safety net for users who run `db install` directly without + * exists as a safety net for users who run `eql install` directly without * `init` first — they still get a working client file rather than failing * later when the config tries to load a non-existent path. */ diff --git a/packages/cli/src/commands/db/config-scaffold.ts b/packages/cli/src/commands/db/config-scaffold.ts index b5e623c4..35947f32 100644 --- a/packages/cli/src/commands/db/config-scaffold.ts +++ b/packages/cli/src/commands/db/config-scaffold.ts @@ -87,7 +87,7 @@ export default defineConfig({ * Returns `true` if a config is present (either pre-existing or freshly * written), `false` if the user cancelled the prompt. * - * Invoked by `db install` when no `stash.config.ts` exists, so users don't + * Invoked by `eql install` when no `stash.config.ts` exists, so users don't * need to run a separate `setup` step before installing EQL. */ export async function ensureStashConfig( diff --git a/packages/cli/src/commands/db/detect.ts b/packages/cli/src/commands/db/detect.ts index 5900a0a8..93b681ee 100644 --- a/packages/cli/src/commands/db/detect.ts +++ b/packages/cli/src/commands/db/detect.ts @@ -34,7 +34,7 @@ export function detectSupabase(databaseUrl: string | undefined): boolean { export interface SupabaseProjectInfo { /** * Whether the migrations directory exists AND is a directory. Used to pick - * the migration-vs-direct default in the `db install --supabase` prompt. + * the migration-vs-direct default in the `eql install --supabase` prompt. */ hasMigrationsDir: boolean /** diff --git a/packages/cli/src/commands/db/install.ts b/packages/cli/src/commands/db/install.ts index 44bc70e8..67553887 100644 --- a/packages/cli/src/commands/db/install.ts +++ b/packages/cli/src/commands/db/install.ts @@ -65,13 +65,20 @@ export interface InstallOptions { * never persisted. See `src/config/database-url.ts`. */ databaseUrl?: string + /** + * EQL generation to install: `'2'` (default, composite `eql_v2_encrypted`) + * or `'3'` (native concrete-domain schema: `public.*` type domains with + * `eql_v3` operators). v3 currently supports the direct install path only — + * not `--drizzle`, `--migration`, `--migrations-dir`, or `--latest`. + */ + eqlVersion?: string } /** Resolved install mode for the Supabase non-Drizzle branch. */ export type SupabaseInstallMode = 'migration' | 'direct' export async function installCommand(options: InstallOptions) { - p.intro(runnerCommand(detectPackageManager(), 'stash db install')) + p.intro(runnerCommand(detectPackageManager(), 'stash eql install')) // Validate mutually-exclusive / supabase-required flags BEFORE doing any // I/O. `--migration` and `--direct` only make sense in the Supabase flow; @@ -84,7 +91,7 @@ export async function installCommand(options: InstallOptions) { process.exit(1) } - // Scaffold stash.config.ts if missing. `db install` is the single command + // Scaffold stash.config.ts if missing. `eql install` is the single command // that gets a project from zero to installed EQL — no separate setup step // (CIP-2986). const configReady = await ensureStashConfig() @@ -101,7 +108,7 @@ export async function installCommand(options: InstallOptions) { }) s.stop('Configuration loaded.') - // Safety net: if the user ran `db install` without first running `init`, + // Safety net: if the user ran `eql install` without first running `init`, // scaffold the encryption client file so config.client points somewhere // real. No-op when the file already exists. ensureEncryptionClient(config.client, process.cwd(), config.databaseUrl) @@ -110,6 +117,18 @@ export async function installCommand(options: InstallOptions) { // CIP-2985. const resolved = resolveProviderOptions(options, config.databaseUrl) + const eqlVersion: 2 | 3 = options.eqlVersion === '3' ? 3 : 2 + + // v3 supports the direct install path only. Explicit --drizzle/--migration + // are rejected up-front by validateInstallFlags; auto-DETECTED drizzle or + // migration modes fall back to direct here rather than erroring. + if (eqlVersion === 3 && resolved.drizzle) { + p.log.info( + 'EQL v3 does not support the Drizzle migration path yet — installing directly.', + ) + resolved.drizzle = false + } + if (resolved.drizzle) { await generateDrizzleMigration(s, { name: options.name, @@ -126,7 +145,8 @@ export async function installCommand(options: InstallOptions) { // running SQL directly. Detection of `supabase/migrations/` only seeds the // prompt default — it never enables `--supabase`. Direct install is the // historical default and remains the fallback when nothing else applies. - if (resolved.supabase) { + // v3 skips the mode selection entirely: direct install only for now. + if (resolved.supabase && eqlVersion === 2) { const projectInfo = detectSupabaseProject( process.cwd(), options.migrationsDir, @@ -139,7 +159,7 @@ export async function installCommand(options: InstallOptions) { // moving part we'd rather defer until someone needs it. if (options.latest) { p.log.error( - '`db install --supabase --migration --latest` is not yet supported. Please open an issue at https://github.com/cipherstash/stack/issues if you need this.', + '`eql install --supabase --migration --latest` is not yet supported. Please open an issue at https://github.com/cipherstash/stack/issues if you need this.', ) p.outro('Installation aborted.') process.exit(1) @@ -205,7 +225,7 @@ export async function installCommand(options: InstallOptions) { if (!options.force) { s.start('Checking if EQL is already installed...') - const installed = await installer.isInstalled() + const installed = await installer.isInstalled({ eqlVersion }) s.stop(installed ? 'EQL is already installed.' : 'EQL is not installed.') if (installed) { @@ -216,11 +236,14 @@ export async function installCommand(options: InstallOptions) { } const source = options.latest ? 'from GitHub (latest)' : 'bundled' - s.start(`Installing EQL extensions (${source})...`) + s.start( + `Installing EQL ${eqlVersion === 3 ? 'v3 ' : ''}extensions (${source})...`, + ) await installer.install({ excludeOperatorFamily, supabase: resolved.supabase, latest: options.latest, + eqlVersion, }) s.stop('EQL extensions installed.') @@ -430,7 +453,7 @@ async function generateDrizzleMigration( // Step 4: Write the EQL SQL (and cs_migrations tracking schema) into // the migration file. Bundling both means `drizzle-kit migrate` rolls // everything needed for `stash encrypt ...` out to each environment - // in one go, rather than requiring an out-of-band `stash db install`. + // in one go, rather than requiring an out-of-band `stash eql install`. s.start('Writing EQL SQL into migration file...') const migrationContents = `${eqlSql}\n\n-- CipherStash encryption-migration tracking schema.\n-- Tracks per-column phase + backfill progress for \`stash encrypt\`.\n${MIGRATIONS_SCHEMA_SQL.trim()}\n` @@ -491,6 +514,31 @@ export function validateInstallFlags(options: InstallOptions): string | null { return '`--migration` and `--direct` are mutually exclusive. Pick one.' } + if ( + options.eqlVersion !== undefined && + options.eqlVersion !== '2' && + options.eqlVersion !== '3' + ) { + return `Unknown \`--eql-version ${options.eqlVersion}\`. Supported values: 2, 3.` + } + + if (options.eqlVersion === '3') { + const incompatible = options.drizzle + ? '--drizzle' + : options.migration + ? '--migration' + : options.latest + ? '--latest' + : // --migrations-dir only feeds the Supabase v2 migration-file path; + // the v3 direct install would silently ignore it — reject instead. + options.migrationsDir !== undefined + ? '--migrations-dir' + : null + if (incompatible) { + return `\`--eql-version 3\` does not support \`${incompatible}\` yet — v3 currently installs via the direct path only.` + } + } + const subFlag = options.migration === true ? '--migration' @@ -501,7 +549,7 @@ export function validateInstallFlags(options: InstallOptions): string | null { : null if (subFlag !== null && options.supabase !== true) { - return `\`${subFlag}\` requires \`--supabase\`. Re-run with \`db install --supabase ${subFlag}\`.` + return `\`${subFlag}\` requires \`--supabase\`. Re-run with \`eql install --supabase ${subFlag}\`.` } return null diff --git a/packages/cli/src/commands/db/status.ts b/packages/cli/src/commands/db/status.ts index 23979dee..29c48cc6 100644 --- a/packages/cli/src/commands/db/status.ts +++ b/packages/cli/src/commands/db/status.ts @@ -44,7 +44,7 @@ export async function statusCommand(options: { databaseUrl?: string } = {}) { } else { s.stop('EQL is not installed.') p.log.warn( - `EQL is not installed. Run \`${runnerCommand(pm, 'stash db install')}\` to install it.`, + `EQL is not installed. Run \`${runnerCommand(pm, 'stash eql install')}\` to install it.`, ) p.outro('Status check complete.') return diff --git a/packages/cli/src/commands/db/supabase-migration.ts b/packages/cli/src/commands/db/supabase-migration.ts index 14d40aea..e1400b46 100644 --- a/packages/cli/src/commands/db/supabase-migration.ts +++ b/packages/cli/src/commands/db/supabase-migration.ts @@ -27,7 +27,7 @@ export const SUPABASE_EQL_MIGRATION_FILENAME = * package manager. */ function migrationHeader(runner: string): string { - return `-- CipherStash EQL — installed by \`${runner} stash db install --supabase --migration\`. + return `-- CipherStash EQL — installed by \`${runner} stash eql install --supabase --migration\`. -- -- This migration installs the CipherStash Encrypt Query Language (EQL) types, -- functions, and operators into the \`eql_v2\` schema, then grants Supabase's diff --git a/packages/cli/src/commands/db/upgrade.ts b/packages/cli/src/commands/db/upgrade.ts index 49fc2db7..3153001a 100644 --- a/packages/cli/src/commands/db/upgrade.ts +++ b/packages/cli/src/commands/db/upgrade.ts @@ -32,7 +32,7 @@ export async function upgradeCommand(options: { if (!installed) { s.stop('EQL is not installed.') p.log.warn( - `EQL is not currently installed. Run "${runnerCommand(pm, 'stash db install')}" first.`, + `EQL is not currently installed. Run "${runnerCommand(pm, 'stash eql install')}" first.`, ) p.outro('Upgrade aborted.') process.exit(1) diff --git a/packages/cli/src/commands/encrypt/drizzle-helper.ts b/packages/cli/src/commands/encrypt/drizzle-helper.ts index 019f39cf..fb775caf 100644 --- a/packages/cli/src/commands/encrypt/drizzle-helper.ts +++ b/packages/cli/src/commands/encrypt/drizzle-helper.ts @@ -6,7 +6,7 @@ import { detectPackageManager, runnerArgv } from '@/commands/init/utils.js' /** * Scaffold a custom Drizzle Kit migration file with a known name and write - * the supplied SQL into it. Mirrors the dance `db install --drizzle` already + * the supplied SQL into it. Mirrors the dance `eql install --drizzle` already * does — `drizzle-kit generate --custom` creates the file and records the * journal entry / snapshot, then we overwrite the empty body with our SQL. * diff --git a/packages/cli/src/commands/init/__tests__/utils.test.ts b/packages/cli/src/commands/init/__tests__/utils.test.ts index 9959843b..704dec34 100644 --- a/packages/cli/src/commands/init/__tests__/utils.test.ts +++ b/packages/cli/src/commands/init/__tests__/utils.test.ts @@ -146,8 +146,8 @@ describe('runnerCommand', () => { }) it('passes the package reference through verbatim (multi-word args allowed)', () => { - expect(runnerCommand('bun', 'stash db install')).toBe( - 'bunx stash db install', + expect(runnerCommand('bun', 'stash eql install')).toBe( + 'bunx stash eql install', ) }) }) diff --git a/packages/cli/src/commands/init/doctrine/AGENTS-doctrine.md b/packages/cli/src/commands/init/doctrine/AGENTS-doctrine.md index 7da721cb..ac62059c 100644 --- a/packages/cli/src/commands/init/doctrine/AGENTS-doctrine.md +++ b/packages/cli/src/commands/init/doctrine/AGENTS-doctrine.md @@ -7,7 +7,7 @@ This document is the **durable rule book** for any agent working on this codebas ## What you are working with - **Encryption client** — a per-project module that defines which tables and columns are encrypted, what data type each column holds, and which search operations are enabled. The path is in `.cipherstash/context.json` under `encryptionClientPath`. -- **EQL extension** — a Postgres extension installed via `stash db install` that provides server-side functions for searchable encryption (`eql_v2.*`). Required before any migration that creates encrypted columns. +- **EQL extension** — a Postgres extension installed via `stash eql install` that provides server-side functions for searchable encryption (`eql_v2.*`). Required before any migration that creates encrypted columns. - **Project context** — `.cipherstash/context.json` records what `stash init` discovered: integration, package manager, env key names (never values), schemas, install command, CLI version. Treat it as authoritative. - **Action plan** — `.cipherstash/setup-prompt.md` is the project-specific to-do list for the current setup run. Read it first. diff --git a/packages/cli/src/commands/init/lib/setup-prompt.ts b/packages/cli/src/commands/init/lib/setup-prompt.ts index 6419aeaf..2e35f65d 100644 --- a/packages/cli/src/commands/init/lib/setup-prompt.ts +++ b/packages/cli/src/commands/init/lib/setup-prompt.ts @@ -129,7 +129,7 @@ const SKILL_PURPOSES: Record = { 'stash-dynamodb': 'DynamoDB encryption: per-item encrypt/decrypt, HMAC attribute keys, audit logging', 'stash-cli': - '`stash` command reference — `status`, `plan`, `impl`, `db install`, `encrypt {backfill,cutover,drop}`, etc.', + '`stash` command reference — `status`, `plan`, `impl`, `eql install`, `encrypt {backfill,cutover,drop}`, etc.', 'stash-secrets': 'storing and retrieving encrypted secrets (separate concern from column encryption)', 'stash-supply-chain-security': diff --git a/packages/cli/src/commands/init/providers/__tests__/base.test.ts b/packages/cli/src/commands/init/providers/__tests__/base.test.ts index 773952b4..f5d58b29 100644 --- a/packages/cli/src/commands/init/providers/__tests__/base.test.ts +++ b/packages/cli/src/commands/init/providers/__tests__/base.test.ts @@ -6,13 +6,13 @@ describe('createBaseProvider getNextSteps', () => { it('uses npx when package manager is npm', () => { const steps = provider.getNextSteps({}, 'npm') - expect(steps[0]).toBe('Set up your database: npx stash db install') + expect(steps[0]).toBe('Set up your database: npx stash eql install') expect(steps[1]).toContain('npx stash wizard') }) it('uses bunx when package manager is bun', () => { const steps = provider.getNextSteps({}, 'bun') - expect(steps[0]).toBe('Set up your database: bunx stash db install') + expect(steps[0]).toBe('Set up your database: bunx stash eql install') expect(steps[1]).toContain('bunx stash wizard') // Sanity: the old hardcoded `npx` should be gone. for (const s of steps) expect(s).not.toMatch(/\bnpx\b/) @@ -20,13 +20,13 @@ describe('createBaseProvider getNextSteps', () => { it('uses pnpm dlx when package manager is pnpm', () => { const steps = provider.getNextSteps({}, 'pnpm') - expect(steps[0]).toBe('Set up your database: pnpm dlx stash db install') + expect(steps[0]).toBe('Set up your database: pnpm dlx stash eql install') expect(steps[1]).toContain('pnpm dlx stash wizard') }) it('uses yarn dlx when package manager is yarn', () => { const steps = provider.getNextSteps({}, 'yarn') - expect(steps[0]).toBe('Set up your database: yarn dlx stash db install') + expect(steps[0]).toBe('Set up your database: yarn dlx stash eql install') }) it('still includes the manual-edit suffix when clientFilePath is set', () => { diff --git a/packages/cli/src/commands/init/providers/__tests__/drizzle.test.ts b/packages/cli/src/commands/init/providers/__tests__/drizzle.test.ts index 43a417a6..ef6ccfe8 100644 --- a/packages/cli/src/commands/init/providers/__tests__/drizzle.test.ts +++ b/packages/cli/src/commands/init/providers/__tests__/drizzle.test.ts @@ -7,14 +7,14 @@ describe('createDrizzleProvider getNextSteps', () => { it('uses npx when package manager is npm', () => { const steps = provider.getNextSteps({}, 'npm') expect(steps[0]).toBe( - 'Set up your database: npx stash db install --drizzle', + 'Set up your database: npx stash eql install --drizzle', ) }) it('uses bunx when package manager is bun', () => { const steps = provider.getNextSteps({}, 'bun') expect(steps[0]).toBe( - 'Set up your database: bunx stash db install --drizzle', + 'Set up your database: bunx stash eql install --drizzle', ) expect(steps[1]).toContain('bunx stash wizard') for (const s of steps) expect(s).not.toMatch(/\bnpx\b/) @@ -23,14 +23,14 @@ describe('createDrizzleProvider getNextSteps', () => { it('uses pnpm dlx when package manager is pnpm', () => { const steps = provider.getNextSteps({}, 'pnpm') expect(steps[0]).toBe( - 'Set up your database: pnpm dlx stash db install --drizzle', + 'Set up your database: pnpm dlx stash eql install --drizzle', ) }) it('uses yarn dlx when package manager is yarn', () => { const steps = provider.getNextSteps({}, 'yarn') expect(steps[0]).toBe( - 'Set up your database: yarn dlx stash db install --drizzle', + 'Set up your database: yarn dlx stash eql install --drizzle', ) }) }) diff --git a/packages/cli/src/commands/init/providers/__tests__/prisma-next.test.ts b/packages/cli/src/commands/init/providers/__tests__/prisma-next.test.ts index 196e07e9..7e5abd61 100644 --- a/packages/cli/src/commands/init/providers/__tests__/prisma-next.test.ts +++ b/packages/cli/src/commands/init/providers/__tests__/prisma-next.test.ts @@ -4,12 +4,12 @@ import { createPrismaNextProvider } from '../prisma-next.js' describe('createPrismaNextProvider getNextSteps', () => { const provider = createPrismaNextProvider() - it('points at prisma-next migration plan + apply rather than stash db install', () => { + it('points at prisma-next migration plan + apply rather than stash eql install', () => { const steps = provider.getNextSteps({}, 'pnpm') // The whole story hinges on this: Prisma Next users never run - // `stash db install` — the framework handles the EQL bundle. + // `stash eql install` — the framework handles the EQL bundle. for (const step of steps) { - expect(step).not.toMatch(/stash db install/) + expect(step).not.toMatch(/stash eql install/) } const planApply = steps.find((s) => s.includes('migration plan')) expect(planApply).toBeDefined() diff --git a/packages/cli/src/commands/init/providers/__tests__/supabase.test.ts b/packages/cli/src/commands/init/providers/__tests__/supabase.test.ts index 0a9d2952..69304e52 100644 --- a/packages/cli/src/commands/init/providers/__tests__/supabase.test.ts +++ b/packages/cli/src/commands/init/providers/__tests__/supabase.test.ts @@ -7,14 +7,14 @@ describe('createSupabaseProvider getNextSteps', () => { it('uses npx when package manager is npm', () => { const steps = provider.getNextSteps({}, 'npm') expect(steps[0]).toBe( - 'Install EQL: npx stash db install --supabase (prompts for migration vs direct)', + 'Install EQL: npx stash eql install --supabase (prompts for migration vs direct)', ) }) it('uses bunx when package manager is bun', () => { const steps = provider.getNextSteps({}, 'bun') expect(steps[0]).toBe( - 'Install EQL: bunx stash db install --supabase (prompts for migration vs direct)', + 'Install EQL: bunx stash eql install --supabase (prompts for migration vs direct)', ) expect(steps[2]).toContain('bunx stash wizard') // wizard step is third for (const s of steps) expect(s).not.toMatch(/\bnpx\b/) @@ -22,13 +22,13 @@ describe('createSupabaseProvider getNextSteps', () => { it('uses pnpm dlx when package manager is pnpm', () => { const steps = provider.getNextSteps({}, 'pnpm') - expect(steps[0]).toContain('pnpm dlx stash db install --supabase') + expect(steps[0]).toContain('pnpm dlx stash eql install --supabase') }) it('uses yarn dlx when package manager is yarn', () => { const steps = provider.getNextSteps({}, 'yarn') expect(steps[0]).toBe( - 'Install EQL: yarn dlx stash db install --supabase (prompts for migration vs direct)', + 'Install EQL: yarn dlx stash eql install --supabase (prompts for migration vs direct)', ) expect(steps[2]).toContain('yarn dlx stash wizard') // Sanity: the supabase CLI commands stay untouched. diff --git a/packages/cli/src/commands/init/providers/base.ts b/packages/cli/src/commands/init/providers/base.ts index 1b74d117..47064d53 100644 --- a/packages/cli/src/commands/init/providers/base.ts +++ b/packages/cli/src/commands/init/providers/base.ts @@ -11,7 +11,7 @@ export function createBaseProvider(): InitProvider { ? `edit ${state.clientFilePath} directly` : 'edit your encryption schema directly' return [ - `Set up your database: ${cli} db install`, + `Set up your database: ${cli} eql install`, `Customize your schema: ${cli} wizard (AI-guided, automated) — or ${manualEdit}`, 'Quickstart: https://cipherstash.com/docs/stack/quickstart', 'Dashboard: https://dashboard.cipherstash.com/workspaces', diff --git a/packages/cli/src/commands/init/providers/drizzle.ts b/packages/cli/src/commands/init/providers/drizzle.ts index 16b5c73f..ac79167f 100644 --- a/packages/cli/src/commands/init/providers/drizzle.ts +++ b/packages/cli/src/commands/init/providers/drizzle.ts @@ -7,7 +7,7 @@ export function createDrizzleProvider(): InitProvider { introMessage: 'Setting up CipherStash for your Drizzle project...', getNextSteps(state: InitState, pm: PackageManager): string[] { const cli = runnerCommand(pm, 'stash') - const steps = [`Set up your database: ${cli} db install --drizzle`] + const steps = [`Set up your database: ${cli} eql install --drizzle`] const manualEdit = state.clientFilePath ? `edit ${state.clientFilePath} directly` diff --git a/packages/cli/src/commands/init/providers/prisma-next.ts b/packages/cli/src/commands/init/providers/prisma-next.ts index 74807757..ab70ab0d 100644 --- a/packages/cli/src/commands/init/providers/prisma-next.ts +++ b/packages/cli/src/commands/init/providers/prisma-next.ts @@ -8,7 +8,7 @@ export function createPrismaNextProvider(): InitProvider { // Note: Prisma Next absorbs the EQL bundle install and schema // scaffold steps via its migration framework. The next-steps list // below therefore points at `prisma-next migration plan|apply` - // instead of `stash db install`, and at `cipherstashFromStack` + // instead of `stash eql install`, and at `cipherstashFromStack` // instead of an `encryption/index.ts` placeholder. getNextSteps(_state, pm: PackageManager): string[] { const stash = runnerCommand(pm, 'stash') diff --git a/packages/cli/src/commands/init/providers/supabase.ts b/packages/cli/src/commands/init/providers/supabase.ts index 5c669fc5..d8b824d9 100644 --- a/packages/cli/src/commands/init/providers/supabase.ts +++ b/packages/cli/src/commands/init/providers/supabase.ts @@ -8,7 +8,7 @@ export function createSupabaseProvider(): InitProvider { getNextSteps(state: InitState, pm: PackageManager): string[] { const cli = runnerCommand(pm, 'stash') const steps = [ - `Install EQL: ${cli} db install --supabase (prompts for migration vs direct)`, + `Install EQL: ${cli} eql install --supabase (prompts for migration vs direct)`, 'Apply it: supabase db reset (local) or supabase migration up (remote)', ] diff --git a/packages/cli/src/commands/init/steps/build-schema.ts b/packages/cli/src/commands/init/steps/build-schema.ts index f23e4782..c6212a30 100644 --- a/packages/cli/src/commands/init/steps/build-schema.ts +++ b/packages/cli/src/commands/init/steps/build-schema.ts @@ -20,7 +20,7 @@ import { generatePlaceholderClient } from '../utils.js' const DEFAULT_CLIENT_PATH = './src/encryption/index.ts' /** - * Pick the integration template by reading the same signals `db install` + * Pick the integration template by reading the same signals `eql install` * uses — Drizzle config / dependency for `drizzle`, Supabase host in * `DATABASE_URL` for `supabase`, otherwise raw Postgres. Silent: never * prompts the user. diff --git a/packages/cli/src/commands/init/steps/install-deps.ts b/packages/cli/src/commands/init/steps/install-deps.ts index 1677dd03..7a77587e 100644 --- a/packages/cli/src/commands/init/steps/install-deps.ts +++ b/packages/cli/src/commands/init/steps/install-deps.ts @@ -17,7 +17,7 @@ const PRISMA_NEXT_PACKAGE = '@cipherstash/prisma-next' * * - `@cipherstash/stack` (prod) — the encryption client and per-integration * helpers (drizzle, supabase, schema). - * - `stash` (dev) — the CLI itself, so the user can run `stash db install`, + * - `stash` (dev) — the CLI itself, so the user can run `stash eql install`, * `stash wizard`, etc. as a project script without the global install. * * Skips silently when both are already present. Prompts before running the diff --git a/packages/cli/src/commands/init/steps/install-eql.ts b/packages/cli/src/commands/init/steps/install-eql.ts index 594fce0b..7dd48fb5 100644 --- a/packages/cli/src/commands/init/steps/install-eql.ts +++ b/packages/cli/src/commands/init/steps/install-eql.ts @@ -5,7 +5,7 @@ import { CancelledError } from '../types.js' import { isPackageInstalled } from '../utils.js' /** - * Run `stash db install` programmatically after a y/N confirm. + * Run `stash eql install` programmatically after a y/N confirm. * * EQL is the Postgres extension every CipherStash query relies on. Without * it, the encryption client can't read or write to encrypted columns. @@ -31,12 +31,12 @@ export const installEqlStep: InitStep = { // Prisma Next ships the EQL bundle as a baseline migration inside // `@cipherstash/prisma-next`. `prisma-next migration apply` runs // it in the same control-plane sweep as the user's application - // migrations — running `stash db install` here would be a + // migrations — running `stash eql install` here would be a // duplicate install and would race with the framework's // migration journal. Skip with guidance instead. if (integration === 'prisma-next' || provider.name === 'prisma-next') { p.log.success( - 'Skipping `stash db install` — Prisma Next installs the EQL bundle via `prisma-next migration apply` (runs alongside your app migrations).', + 'Skipping `stash eql install` — Prisma Next installs the EQL bundle via `prisma-next migration apply` (runs alongside your app migrations).', ) return { ...state, eqlInstalled: false } } @@ -55,7 +55,7 @@ export const installEqlStep: InitStep = { if (!proceed) { p.log.info('Skipping EQL installation.') p.note( - 'Run `stash db install` before applying any migration that references encrypted columns.', + 'Run `stash eql install` before applying any migration that references encrypted columns.', 'EQL not installed', ) return { ...state, eqlInstalled: false } @@ -91,7 +91,7 @@ export const installEqlStep: InitStep = { p.log.error( 'EQL install failed — check your database connection and try again.', ) - p.note('Re-run with: stash db install', 'You can retry manually') + p.note('Re-run with: stash eql install', 'You can retry manually') return { ...state, eqlInstalled: false } } diff --git a/packages/cli/src/commands/init/utils.ts b/packages/cli/src/commands/init/utils.ts index e3076fb7..7d8e3c4e 100644 --- a/packages/cli/src/commands/init/utils.ts +++ b/packages/cli/src/commands/init/utils.ts @@ -150,7 +150,7 @@ export function combinedInstallCommands( * yarn → `yarn dlx` * * `ref` is appended verbatim, so callers may pass `'stash'` or - * `'stash db install'`. + * `'stash eql install'`. */ export function runnerCommand(pm: PackageManager, ref: string): string { switch (pm) { diff --git a/packages/cli/src/installer/index.ts b/packages/cli/src/installer/index.ts index 108b8b4a..be8352b5 100644 --- a/packages/cli/src/installer/index.ts +++ b/packages/cli/src/installer/index.ts @@ -8,25 +8,51 @@ 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' +// 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 and grant target. +const EQL_V3_SCHEMA_NAME = 'eql_v3' /** - * SQL block that grants the EQL schema, tables, routines, and sequences to - * Supabase's built-in roles (`anon`, `authenticated`, `service_role`). + * Which EQL generation to install / inspect. `2` is the composite + * `eql_v2_encrypted` type; `3` is the native concrete-domain schema + * (`public.*` domains, `eql_v3` operators). + */ +export type EqlVersion = 2 | 3 + +function schemaNameFor(eqlVersion: EqlVersion): string { + return eqlVersion === 3 ? EQL_V3_SCHEMA_NAME : EQL_SCHEMA_NAME +} + +/** + * Build the SQL block that grants an EQL schema, tables, routines, and + * sequences to Supabase's built-in roles (`anon`, `authenticated`, + * `service_role`). * * Supabase uses dedicated roles that don't own the schema, so explicit grants - * are required. We expose this as a single multi-statement string so it can be + * are required. Returned as a single multi-statement string so it can be * executed in one `client.query()` (Postgres accepts multi-statement strings) * AND embedded directly into a Supabase migration file. One source of truth - * for both the runtime install path and the generated migration file. + * for both the runtime install path and the generated migration file, shared + * by the v2 (`eql_v2`) and v3 (`eql_v3`) installs. */ -export const SUPABASE_PERMISSIONS_SQL = `GRANT USAGE ON SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT SELECT ON ALL TABLES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${EQL_SCHEMA_NAME} TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT SELECT ON TABLES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; -ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${EQL_SCHEMA_NAME} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; +export function supabasePermissionsSql(schemaName: string): string { + return `GRANT USAGE ON SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT EXECUTE ON ALL ROUTINES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +GRANT USAGE ON ALL SEQUENCES IN SCHEMA ${schemaName} TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT SELECT ON TABLES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT EXECUTE ON ROUTINES TO anon, authenticated, service_role; +ALTER DEFAULT PRIVILEGES FOR ROLE postgres IN SCHEMA ${schemaName} GRANT USAGE ON SEQUENCES TO anon, authenticated, service_role; ` +} + +/** The v2 (`eql_v2`) Supabase grants block. See {@link supabasePermissionsSql}. */ +export const SUPABASE_PERMISSIONS_SQL = supabasePermissionsSql(EQL_SCHEMA_NAME) + +/** The v3 (`eql_v3`) Supabase grants block. See {@link supabasePermissionsSql}. */ +export const SUPABASE_PERMISSIONS_SQL_V3 = + supabasePermissionsSql(EQL_V3_SCHEMA_NAME) /** * Get the directory of the current file, supporting both ESM and CJS. @@ -165,9 +191,10 @@ export class EQLInstaller { } /** - * Check whether the EQL extension is installed by looking for the `eql_v2` schema. + * Check whether the EQL extension is installed by looking for its schema + * (`eql_v2` by default, `eql_v3` when `eqlVersion: 3`). */ - async isInstalled(): Promise { + async isInstalled(options?: { eqlVersion?: EqlVersion }): Promise { const client = new pg.Client({ connectionString: this.databaseUrl }) try { @@ -175,7 +202,7 @@ export class EQLInstaller { const result = await client.query( 'SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1', - [EQL_SCHEMA_NAME], + [schemaNameFor(options?.eqlVersion ?? 2)], ) return result.rowCount !== null && result.rowCount > 0 @@ -195,7 +222,10 @@ export class EQLInstaller { * This is best-effort: if the schema exists but no version metadata is * available, `'unknown'` is returned. */ - async getInstalledVersion(): Promise { + async getInstalledVersion(options?: { + eqlVersion?: EqlVersion + }): Promise { + const schemaName = schemaNameFor(options?.eqlVersion ?? 2) const client = new pg.Client({ connectionString: this.databaseUrl }) try { @@ -203,7 +233,7 @@ export class EQLInstaller { const schemaResult = await client.query( 'SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1', - [EQL_SCHEMA_NAME], + [schemaName], ) if (schemaResult.rowCount === null || schemaResult.rowCount === 0) { @@ -215,7 +245,7 @@ export class EQLInstaller { // we fall back to 'unknown'. try { const versionResult = await client.query( - `SELECT ${EQL_SCHEMA_NAME}.version() AS version`, + `SELECT ${schemaName}.version() AS version`, ) if (versionResult.rows.length > 0 && versionResult.rows[0].version) { @@ -249,12 +279,26 @@ export class EQLInstaller { excludeOperatorFamily?: boolean supabase?: boolean latest?: boolean + eqlVersion?: EqlVersion }): Promise { - const { supabase = false, latest = false } = options ?? {} + const { supabase = false, latest = false, eqlVersion = 2 } = options ?? {} const excludeOperatorFamily = options?.excludeOperatorFamily || supabase + + if (latest && eqlVersion === 3) { + // No public v3 release artifacts exist yet — the v3 bundles are vendored + // from the generated monolith (see scripts/build-eql-v3-sql.mjs). + throw new Error( + '`--latest` is not supported for EQL v3 yet: no public v3 release artifacts exist. Use the bundled install.', + ) + } + const sql = latest ? await this.downloadInstallScript(excludeOperatorFamily) - : this.loadBundledInstallScript({ excludeOperatorFamily, supabase }) + : this.loadBundledInstallScript({ + excludeOperatorFamily, + supabase, + eqlVersion, + }) const client = new pg.Client({ connectionString: this.databaseUrl }) @@ -272,7 +316,7 @@ export class EQLInstaller { await client.query(sql) if (supabase) { - await this.grantSupabasePermissions(client) + await this.grantSupabasePermissions(client, eqlVersion) } await client.query('COMMIT') @@ -291,16 +335,19 @@ export class EQLInstaller { } /** - * Grant Supabase roles access to the eql_v2 schema. + * Grant Supabase roles access to the installed EQL schema. * * Supabase uses dedicated roles (anon, authenticated, service_role) that - * don't own the schema, so explicit grants are required. Issues - * {@link SUPABASE_PERMISSIONS_SQL} as a single multi-statement query — + * don't own the schema, so explicit grants are required. Issues the + * {@link supabasePermissionsSql} block as a single multi-statement query — * Postgres accepts that and it keeps the SQL identical to what we'd write * into a Supabase migration file. */ - private async grantSupabasePermissions(client: pg.Client): Promise { - await client.query(SUPABASE_PERMISSIONS_SQL) + private async grantSupabasePermissions( + client: pg.Client, + eqlVersion: EqlVersion, + ): Promise { + await client.query(supabasePermissionsSql(schemaNameFor(eqlVersion))) } /** @@ -309,6 +356,7 @@ export class EQLInstaller { private loadBundledInstallScript(options: { excludeOperatorFamily: boolean supabase: boolean + eqlVersion: EqlVersion }): string { const filename = resolveBundledFilename(options) @@ -358,11 +406,21 @@ export class EQLInstaller { * - `supabase: true` → Supabase-specific variant * - `excludeOperatorFamily: true` → no operator family variant * - default → standard install + * + * For EQL v3 the Supabase variant IS the no-operator-family variant (the v3 + * bundle's only superuser-requiring statements are its two operator-class + * chunks), so both flags resolve to the same file. */ function resolveBundledFilename(options: { excludeOperatorFamily: boolean supabase: boolean + eqlVersion?: EqlVersion }): string { + if ((options.eqlVersion ?? 2) === 3) { + if (options.supabase || options.excludeOperatorFamily) + return 'cipherstash-encrypt-v3-supabase.sql' + return 'cipherstash-encrypt-v3.sql' + } if (options.supabase) return 'cipherstash-encrypt-supabase.sql' if (options.excludeOperatorFamily) return 'cipherstash-encrypt-no-operator-family.sql' @@ -373,11 +431,16 @@ function resolveBundledFilename(options: { * Load the bundled EQL install SQL. Used by the Drizzle migration path. */ export function loadBundledEqlSql( - options: { excludeOperatorFamily?: boolean; supabase?: boolean } = {}, + options: { + excludeOperatorFamily?: boolean + supabase?: boolean + eqlVersion?: EqlVersion + } = {}, ): string { const filename = resolveBundledFilename({ excludeOperatorFamily: options.excludeOperatorFamily ?? false, supabase: options.supabase ?? false, + eqlVersion: options.eqlVersion ?? 2, }) try { diff --git a/packages/cli/src/messages.ts b/packages/cli/src/messages.ts index 822f87e2..d4c51dea 100644 --- a/packages/cli/src/messages.ts +++ b/packages/cli/src/messages.ts @@ -35,8 +35,14 @@ export const messages = { selectRegion: 'Select a region', cancelled: 'Cancelled.', }, + eql: { + unknownSubcommand: 'Unknown eql subcommand', + }, db: { unknownSubcommand: 'Unknown db subcommand', + /** Warning shown when the deprecated `db install` alias for `eql install` is used. */ + installDeprecated: (stashRef: string) => + `"${stashRef} db install" is deprecated — use "${stashRef} eql install" instead.`, migrateNotImplemented: (stashRef: string) => `"${stashRef} db migrate" is not yet implemented.`, /** Source labels surfaced after DATABASE_URL resolution. */ diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql b/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql new file mode 100644 index 00000000..552dbf84 --- /dev/null +++ b/packages/cli/src/sql/cipherstash-encrypt-v3-supabase.sql @@ -0,0 +1,43251 @@ +--! @file v3/schema.sql +--! @brief EQL v3 schema creation +--! +--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted +--! domains (public.integer, public.bigint, and future scalar domains) live in +--! public so application tables survive EQL schema uninstall. eql_v3 is the +--! public API for index-term extractors, aggregates, AND the operator-backing +--! comparison wrappers +--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment +--! helpers). The wrappers are public because they are the function-form +--! equivalent of every supported operator: platforms without operator support +--! (Supabase/PostgREST calls functions, not operators) invoke them by name. +--! eql_v3_internal houses INTERNAL implementation objects only: the +--! searchable-encrypted-metadata (SEM) index-term types +--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! functions, the unsupported-operator blockers (which only raise), and the +--! aggregate state functions. Together the two schemas are self-contained — +--! they own every type they need and have no runtime dependency on another EQL +--! schema. +--! +--! Drops existing schema if present to support clean reinstallation. +--! +--! @warning DROP SCHEMA CASCADE will remove all objects in the schema +--! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! +--! @note DESIGN DECISION — EQL never grants permissions automatically. This +--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! access is strictly opt-in. A deployment that exposes EQL to +--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) +--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! the functions it needs. This is intentional least-privilege, not an +--! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! part of the public API and normally needs no grant; where a caller +--! reaches an internal object indirectly (a public operator/aggregate +--! whose backing state-fn/blocker lives there), grant it deliberately. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +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/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller +--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` — +--! both reached exclusively from plpgsql and btree operator-class support +--! contexts, where SQL functions can NEVER be inlined and instead pay the +--! per-call SQL-function executor (measured 3.5x the per-call cost of the +--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql +--! caches its plan across calls. The non-array guard preserves the v3 +--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original +--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`), +--! so the divergence stays unreachable in practice; JSON null and empty +--! array still return NULL exactly as before. +CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ +DECLARE + result bytea[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(decode(value::text, 'hex')::bytea) + INTO result + FROM jsonb_array_elements_text(val) AS value; + RETURN result; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The DEV placeholder is replaced with the actual release +--! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, +--! or "DEV" for development builds. + +--! @brief Get the installed EQL version string +--! +--! Returns the version string for the installed EQL library. This value is +--! baked in at build time from the release tag. +--! +--! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) +--! +--! @note Auto-generated during build from src/v3/version.template +--! +--! Example: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 'DEV'; +$$ LANGUAGE SQL; + +--! @brief Schema-level version marker for obj_description() discoverability +--! +--! Mirrors eql_v3.version() as a comment on the schema so the installed +--! version can also be read via obj_description('eql_v3'::regnamespace). +COMMENT ON SCHEMA eql_v3 IS 'DEV'; + +--! @file v3/sem/ore_block_256/types.sql +--! @brief ORE block index-term types (eql_v3 SEM). +--! +--! 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/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/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)'; + +--! @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/hmac_256/functions.sql +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). +--! +--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and +--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! domains extract from the jsonb payload directly via a cast to the domain. +--! (Doc comments deliberately avoid naming eql_v2 symbols so the +--! self-containment grep stays clean.) + +--! @brief Extract HMAC-SHA256 index term from JSONB payload +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! (which calls this) engage structurally. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) + RETURNS eql_v3_internal.hmac_256 + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 +$$; + + +--! @brief Check if JSONB payload contains HMAC-SHA256 index term +--! +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True if 'hm' field is present and non-null +CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) + RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm') IS NOT NULL +$$; + +--! @file v3/sem/bloom_filter/types.sql +--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. + +--! @brief Bloom-filter index term: a bit array stored as smallint[]. +--! +--! Backs the `match` capability (`@>` / `<@`) on `eql_v3_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/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 +$$; + +--! @brief EQL lint: detect non-inlinable operator implementation functions +--! +--! Returns one row per violation found in the installed `eql_v3` surface. The +--! Postgres planner can only inline a function during index matching when: +--! +--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) +--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into +--! index expressions) +--! * No `SET` clauses (e.g. `SET search_path = ...`) +--! * Not `SECURITY DEFINER` +--! * Single-statement SELECT body +--! +--! @note The single-statement SELECT body condition is **not yet checked** by +--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, +--! or any pre-SELECT statement will pass all four implemented checks while +--! remaining non-inlinable. Implementing the check requires walking `prosrc` +--! (or `pg_get_functiondef`); tracked as a follow-up. +--! +--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and +--! the SEM index-term types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) whose +--! implementation functions fail any of these rules silently fall back to seq +--! scan when the documented functional indexes (`eql_v3.eq_term(col)`, +--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. +--! +--! Severity: +--! `error` — fixable, blocks index matching, ship-blocking. +--! `warning` — likely-fixable, may not block matching but signals intent. +--! `info` — observational; useful for review, not a defect on its own. +--! +--! Categories: +--! `inlinability_language` — implementation function isn't `LANGUAGE sql`. +--! `inlinability_volatility` — implementation function is VOLATILE. +--! `inlinability_set_clause` — implementation function has a `SET` clause. +--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. +--! `inlinability_transitive` — implementation function is itself inlinable +--! but its body invokes a non-inlinable function +--! (depth 1; the planner can't peek through +--! that boundary). +--! `blocker_language` — encrypted-domain blocker is not LANGUAGE +--! plpgsql. The planner can inline / elide a +--! LANGUAGE sql body when the result is +--! provably unused, silently bypassing the +--! RAISE that the blocker exists to perform. +--! `blocker_strict` — encrypted-domain blocker is STRICT. +--! PostgreSQL skips the body and returns NULL +--! on NULL arguments, silently bypassing the +--! RAISE. +--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from +--! another encrypted domain rather than jsonb. +--! Operators resolve against the ultimate base +--! type, so the derived domain does not +--! inherit the base domain's blocker surface. +--! `domain_opclass` — an operator class is declared FOR TYPE on an +--! `eql_v3` encrypted domain. Opclasses on +--! domains bypass operator resolution; use a +--! functional index on the extractor instead. +--! `schema_placement` — a naked composite or enum TYPE lives in the +--! public `eql_v3` schema. Internal index-term +--! types (e.g. `ore_block_256_term`) belong in +--! `eql_v3_internal`; a composite/enum in +--! `eql_v3` clutters the Supabase Table Builder +--! type picker, which the schema split exists to +--! prevent. Move it to `eql_v3_internal`. +--! +--! @example +--! ``` +--! SELECT severity, category, object_name, message +--! FROM eql_v3.lints() +--! WHERE severity = 'error' +--! ORDER BY category, object_name; +--! ``` +--! +--! @return SETOF record (severity text, category text, object_name text, message text) +CREATE OR REPLACE FUNCTION eql_v3.lints() +RETURNS TABLE ( + severity text, + category text, + object_name text, + message text +) +LANGUAGE sql STABLE +AS $$ + WITH + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), + + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). + eql_operators AS ( + SELECT + op.oid AS oprid, + op.oprname AS opname, + op.oprcode AS implfunc, + op.oprleft::regtype AS lhs, + op.oprright::regtype AS rhs, + op.oprcode::regprocedure AS impl_signature + FROM pg_operator op + WHERE EXISTS ( + SELECT 1 FROM pg_type t + WHERE t.oid IN (op.oprleft, op.oprright) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) + ) + ), + + -- Cross-join with each operator's implementation function metadata. + -- One row per operator; columns describe the inlinability of the impl. + op_impl AS ( + SELECT + eo.opname, + eo.lhs, + eo.rhs, + eo.implfunc AS impl_oid, + eo.impl_signature::text AS impl_signature, + lang_l.lanname AS lang, + p.provolatile AS volatility, + p.proconfig AS config, + p.prosecdef AS secdef, + p.prosrc AS body + FROM eql_operators eo + JOIN pg_proc p ON p.oid = eo.implfunc + JOIN pg_language lang_l ON lang_l.oid = p.prolang + ), + + -- Encrypted-domain blockers: functions in `eql_v3` whose body contains + -- a blocker marker emitted by the codegen (any of the + -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean + -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the + -- literal `is not supported for` for older path-operator blockers) AND + -- that take at least one encrypted domain over jsonb argument. The argument + -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` + -- helpers themselves, which contain the marker in their body but are not + -- blockers (they take text arguments, not a domain). + encrypted_domain_blockers AS ( + SELECT + p.oid AS oid, + p.oid::regprocedure::text AS signature, + lang_l.lanname AS lang, + p.proisstrict AS isstrict + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND (p.prosrc LIKE '%encrypted_domain_unsupported%' + OR p.prosrc LIKE '%is not supported for%') + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Direct inlinability checks: each row examines one operator's │ + -- │ implementation function and emits a violation if any rule is │ + -- │ broken. Multiple violations on the same function become │ + -- │ multiple rows (developers see every reason it doesn't inline). │ + -- └─────────────────────────────────────────────────────────────────┘ + + SELECT + 'error' AS severity, + 'inlinability_language' AS category, + format('operator %s(%s, %s) -> %s', + opname, lhs, rhs, impl_signature) AS object_name, + format( + 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.', + lang, opname) AS message + FROM op_impl + WHERE lang <> 'sql' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_volatility', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).', + opname) + FROM op_impl + WHERE volatility = 'v' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_set_clause', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.') + FROM op_impl + WHERE config IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_secdef', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' + FROM op_impl + WHERE secdef + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Transitive inlinability: an operator implementation function │ + -- │ that's itself inlinable can still fail to inline if its body │ + -- │ calls a non-inlinable function. Walk one level via pg_depend. │ + -- │ │ + -- │ Postgres records function-to-function dependencies in │ + -- │ pg_depend with deptype 'n' (normal) when one function references│ + -- │ another in its body — but only at CREATE time and only for │ + -- │ direct calls. This is good enough for v1; deeper transitive │ + -- │ analysis is a follow-up. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'inlinability_transitive', + format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, + oi.impl_signature), + format( + 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.', + called.proname, + called_lang.lanname, + CASE called.provolatile + WHEN 'i' THEN 'IMMUTABLE' + WHEN 's' THEN 'STABLE' + WHEN 'v' THEN 'VOLATILE' + END, + CASE WHEN called.proconfig IS NOT NULL + THEN ', has SET clause' + ELSE '' END) + FROM op_impl oi + -- Only worth the transitive check if the outer function is otherwise + -- inlinable — otherwise the direct lints above already report it. + JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure + JOIN pg_depend d + ON d.classid = 'pg_proc'::regclass + AND d.objid = outer_p.oid + AND d.refclassid = 'pg_proc'::regclass + AND d.deptype = 'n' + JOIN pg_proc called ON called.oid = d.refobjid + JOIN pg_language called_lang ON called_lang.oid = called.prolang + WHERE oi.lang = 'sql' + AND oi.volatility IN ('i', 's') + AND oi.config IS NULL + AND NOT oi.secdef + AND called.oid <> outer_p.oid + AND ( + called_lang.lanname <> 'sql' + OR called.provolatile = 'v' + OR called.proconfig IS NOT NULL + OR called.prosecdef + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ + -- │ have inverted inlinability requirements vs operator impls. │ + -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ + -- │ blocker returns NULL on NULL args. Both silently re-enable │ + -- │ operators the storage variant is supposed to block. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'blocker_language', + format('function %s', signature), + format( + 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.', + lang) + FROM encrypted_domain_blockers + WHERE lang <> 'plpgsql' + + UNION ALL + + SELECT + 'error', + 'blocker_strict', + format('function %s', signature), + 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' + FROM encrypted_domain_blockers + WHERE isstrict + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain identity: an encrypted-domain must be defined directly │ + -- │ over jsonb. Operators resolve against the ultimate base type, │ + -- │ so domain-over-domain inherits jsonb's operator surface and not │ + -- │ the base domain's blockers. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'domain_over_domain', + format('domain %I.%I', dn.nspname, dt.typname), + format( + 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.', + dn.nspname, dt.typname, bn.nspname, bt.typname) + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND bt.typtype = 'd' + AND bt.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain opclass: an operator class declared FOR TYPE on an │ + -- │ encrypted-domain bypasses operator resolution at index time. │ + -- │ Use a functional index on the extractor instead. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'domain_opclass', + format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), + format( + 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.', + cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) + FROM pg_catalog.pg_opclass oc + JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype + JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace + JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace + WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Schema placement: the public `eql_v3` schema must hold only the │ + -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ + -- │ there is an internal index-term type in the wrong schema — it │ + -- │ clutters the Supabase type picker the split exists to keep clean. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'schema_placement', + format('type %I.%I', n.nspname, t.typname), + format( + 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.', + n.nspname, t.typname, + CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'eql_v3' + AND t.typtype IN ('c', 'e') + + ORDER BY 1, 2, 3; +$$; + +COMMENT ON FUNCTION eql_v3.lints() IS + 'EQL lint: returns one row per non-inlinable operator implementation. ' + 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' + 'CI-gateable check that all operator implementations on eql_v3 types are ' + 'eligible for planner inlining.'; + +--! @file v3/sem/ore_cllw/types.sql +--! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) +--! +--! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing +--! Encryption. The ciphertext is stored in the `oc` field of encrypted data +--! payloads (Standard-mode `ste_vec` elements). Used by the range operators +--! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. +--! +--! The wire-format `oc` value is a hex string with a leading domain-tag byte +--! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The +--! decoded `bytes` field carries the full byte string including the tag — the +--! comparator is variable-length capable, so numeric and string values within +--! the same column order correctly: the domain tag separates the ranges +--! (numeric < string) and the within-domain comparison falls through to the +--! CLLW per-byte protocol. +--! +--! @note This is a transient type used only during query execution. +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE TYPE eql_v3_internal.ore_cllw AS ( + bytes bytea +); + +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars//. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. + +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.jsonb_entry — a single sv element (returned by `->`). +--! - public.jsonb_query — a containment needle (sv elements, no ciphertext). + +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `oc`). +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `oc`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! public.jsonb_query domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; + +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.json` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.json`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'json' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; +END +$$; + +--! @brief Domain type for an individual sv element. +--! +--! A single element inside an `sv` array: a JSON object that carries a selector +--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for +--! hash-equality) or `oc` (CLLW ORE, for ordered queries) — they are mutually +--! exclusive. This is the type returned by `->` and accepted by the per-entry +--! extractors `eql_v3.eq_term` / `eql_v3.ore_cllw`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'oc')) + OR + (jsonb_typeof(VALUE -> 'oc') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; + +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"","hm":""}]}'::public.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.jsonb_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::public.jsonb_query`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_query AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_query IS 'EQL JSONB query operand (containment)'; +END +$$; + +--! @brief Convert a public.json to a jsonb_query needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! are stripped. This is the canonical needle shape for `@>` containment. +--! Designed for use as a functional GIN index expression: +--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! +--! @param e public.json Source encrypted payload +--! @return public.jsonb_query Query-shaped needle, sv elements normalised. +--! @see public.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.json) + RETURNS public.jsonb_query + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT jsonb_build_object( + 'sv', + coalesce( + (SELECT jsonb_agg( + jsonb_strip_nulls( + jsonb_build_object( + 's', elem -> 's', + 'hm', elem -> 'hm', + 'oc', elem -> 'oc' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::public.jsonb_query +$$; + +CREATE CAST (public.json AS public.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/sem/ore_block_256/functions.sql +--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! +--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The +--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array +--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and +--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Convert JSONB array to ORE block composite type +--! @internal +--! @param val jsonb Array of hex-encoded ORE block terms +--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller +--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached +--! from an inlinable context — as `LANGUAGE sql` it paid the per-call +--! SQL-function executor on every compared value in the opclass hot path +--! (measured: +43% on ORE ordered scans vs the plpgsql form). The +--! non-array guard preserves the v3 behaviour (returns NULL for a +--! non-array scalar; the v2 plpgsql original raised); the caller only +--! reaches this when `has_ore_block_256(val)` is true, which requires +--! `val->'ob'` to be a JSON array, so that branch stays unreachable. +--! An empty array (`ob: []`, what encrypting the empty string `""` produces) +--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. +--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and +--! NULL terms make the comparator return NULL (so an empty-text row silently +--! drops out of ordered queries). An empty array instead engages the +--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every +--! non-empty term. See issue #262 (pinned by T7). +CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE +AS $$ +DECLARE + terms eql_v3_internal.ore_block_256_term[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + INTO terms + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b; + -- plpgsql pitfall: `SELECT INTO ` assigns the + -- select-list columns FIELD-WISE into the variable — return the row + -- constructor directly instead. The COALESCE stays load-bearing for the + -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and + -- the comparator needs an EMPTY terms array, not NULL terms. + RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; + + +--! @brief Extract ORE block index term from JSONB payload +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ore_block_256 ORE block index term +--! @throws Exception if 'ob' field is missing +CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) + RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without + -- entering the body, so no explicit `val IS NULL` guard is needed. + IF eql_v3_internal.has_ore_block_256(val) THEN + RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + END IF; + RAISE 'Expected an ore index (ob) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Check if JSONB payload contains an ORE block index term +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True only if the 'ob' field is present and is a JSON array +--! @note A well-formed ORE index term is always a JSON array of block terms, so +--! this guard treats a present-but-non-array `ob` (a scalar or object) as +--! absent. That makes the extractor `ore_block_256(val)` RAISE on a +--! structurally invalid `ob` payload at the boundary instead of silently +--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The +--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so +--! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) +--! both remain `false`. +CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare two ORE block terms using cryptographic comparison +--! @internal +--! @param a eql_v3_internal.ore_block_256_term First ORE term +--! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @return integer -1 if a < b, 0 if a = b, 1 if a > b +--! @throws Exception if ciphertexts are different lengths +--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` +--! overloads all are). This deliberately diverges from the v2 originals, +--! which carry no volatility marker and so default to `VOLATILE`. The +--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, +--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the +--! planner fold/cache these in ordering and index contexts. NOT `STRICT`: +--! the NULL-handling branches below are load-bearing for the array overload. +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) + RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + eq boolean := true; + unequal_block smallint := 0; + hash_key bytea; + data_block bytea; + encrypt_block bytea; + target_block bytea; + + left_block_size CONSTANT smallint := 16; + right_block_size CONSTANT smallint := 32; + + -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. + -- Wire format per term: + -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] + -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 + -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric + -- (N=14, 702B) with one comparator. + n integer; + left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) + right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) + + indicator smallint := 0; + BEGIN + IF a IS NULL AND b IS NULL THEN + RETURN 0; + END IF; + + IF a IS NULL THEN + RETURN -1; + END IF; + + IF b IS NULL THEN + RETURN 1; + END IF; + + IF bit_length(a.bytes) != bit_length(b.bytes) THEN + RAISE EXCEPTION 'Ciphertexts are different lengths'; + END IF; + + -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The + -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 + -- and derives N = 0, which would fall through to the all-blocks-equal path + -- and return 0 instead of raising. The `<= 16` clause is load-bearing. + IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN + RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); + END IF; + + n := (octet_length(a.bytes) - 16) / 49; + left_offset := 1 + n; -- left blocks begin right after the N PRP bytes + right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT + + FOR block IN 0..n-1 LOOP + -- Compare each PRP byte (the first N bytes) and its 16-byte left block. + IF + substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) + OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) + THEN + IF eq THEN + unequal_block := block; + END IF; + eq = false; + END IF; + END LOOP; + + IF eq THEN + RETURN 0::integer; + END IF; + + -- Hash key is the IV from the right CT of b. + hash_key := substr(b.bytes, right_offset + 1, 16); + + -- First right block is at right_offset + nonce_size (ordinally indexed). + target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); + + data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); + + encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); + + indicator := ( + get_bit( + encrypt_block, + 0 + ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; + + IF indicator = 1 THEN + RETURN 1::integer; + ELSE + RETURN -1::integer; + END IF; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare arrays of ORE block terms recursively +--! @internal +--! @param a eql_v3_internal.ore_block_256_term[] First array +--! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @return integer -1/0/1, or NULL if either array is NULL +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + cmp_result integer; + BEGIN + IF a IS NULL OR b IS NULL THEN + RETURN NULL; + END IF; + + IF cardinality(a) = 0 AND cardinality(b) = 0 THEN + RETURN 0; + END IF; + + IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN + RETURN -1; + END IF; + + IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN + RETURN 1; + END IF; + + cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + + IF cmp_result = 0 THEN + RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + END IF; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @brief Compare ORE block composite types +--! @internal +--! @param a eql_v3_internal.ore_block_256 First ORE block +--! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @return integer -1/0/1 +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + END +$$ LANGUAGE plpgsql; + +--! @file v3/sem/ore_cllw/functions.sql +--! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). + +--! @brief Extract CLLW ORE index term from raw jsonb +--! +--! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element +--! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds +--! the body into the calling query. +--! +--! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with +--! NULL bytes) when `oc` is absent, so btree's NULL handling filters those +--! rows from range queries. +--! +--! @param val jsonb An object carrying an `oc` field +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL +--! when the `oc` field is absent. +--! @see eql_v3_internal.has_ore_cllw +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a raw jsonb value contains a CLLW ORE index term +--! @param val jsonb An object that may carry an `oc` field +--! @return boolean True if `oc` field is present and non-null +CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT val ->> 'oc' IS NOT NULL +$$; + +COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; + +--! @brief CLLW per-byte comparison helper +--! @internal +--! +--! Byte-by-byte comparison implementing the CLLW order-revealing protocol. +--! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` +--! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs +--! MUST be the same length (the caller guarantees this). Stays `LANGUAGE +--! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. +--! +--! @param a bytea First CLLW ciphertext slice +--! @param b bytea Second CLLW ciphertext slice +--! @return integer -1, 0, or 1 +--! @throws Exception if inputs are different lengths +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + i INT; + first_diff INT := 0; +BEGIN + + len_a := LENGTH(a); + len_b := LENGTH(b); + + IF len_a != len_b THEN + RAISE EXCEPTION 'ore_cllw index terms are not the same length'; + END IF; + + FOR i IN 1..len_a LOOP + IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN + first_diff := i; + END IF; + END LOOP; + + IF first_diff = 0 THEN + RETURN 0; + END IF; + + IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN + RETURN 1; + ELSE + RETURN -1; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @brief Variable-length CLLW ORE term comparison +--! @internal +--! +--! Three-way comparison of two CLLW ORE ciphertext terms of potentially +--! different lengths. Compares the shared prefix via the CLLW per-byte +--! protocol; on equal prefixes, the shorter input sorts first. The leading +--! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays +--! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. +--! +--! btree filters NULL composites at the row level, so this should never see a +--! NULL composite under normal operation; the IS-NULL guard returns NULL +--! defensively. A non-NULL composite with NULL `bytes` is a contract violation +--! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise +--! loudly rather than silently misorder. +--! +--! @param a eql_v3_internal.ore_cllw First term +--! @param b eql_v3_internal.ore_cllw Second term +--! @return integer -1, 0, or 1; NULL if either composite is NULL +--! @throws Exception if either composite has a NULL `bytes` field +--! @see eql_v3_internal.compare_ore_cllw_term_bytes +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + common_len INT; + cmp_result INT; +BEGIN + -- The `::text` cast is load-bearing, not a stylistic choice. For the + -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE + -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first + -- means a NULL-component composite falls THROUGH to the RAISE below (the + -- extractor-invariant violation) instead of silently returning NULL and + -- masking it. A plain `a IS NULL` would reintroduce that masking bug. + IF a::text IS NULL OR b::text IS NULL THEN + RETURN NULL; + END IF; + + IF a.bytes IS NULL OR b.bytes IS NULL THEN + RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; + END IF; + + len_a := LENGTH(a.bytes); + len_b := LENGTH(b.bytes); + + IF len_a = 0 AND len_b = 0 THEN + RETURN 0; + ELSIF len_a = 0 THEN + RETURN -1; + ELSIF len_b = 0 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + common_len := len_a; + ELSE + common_len := len_b; + END IF; + + cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( + SUBSTRING(a.bytes FROM 1 FOR common_len), + SUBSTRING(b.bytes FROM 1 FOR common_len) + ); + + IF cmp_result = -1 THEN + RETURN -1; + ELSIF cmp_result = 1 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + RETURN -1; + ELSIF len_a > len_b THEN + RETURN 1; + ELSE + RETURN 0; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for public.json. +--! +--! public.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.jsonb_entry only, not on the root +--! document domain. +--! Every OTHER native jsonb operator reachable via domain fallback against the +--! base type jsonb is BLOCKED here so an encrypted column can never silently +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b text Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.json, b text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonpath Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonpath Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return text Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.json, b text[]) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a public.json Left operand (encrypted payload). +--! @param b text Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.json, b text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a public.json Left operand (encrypted payload). +--! @param b integer Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.json, b integer) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = public.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root public.json document comparisons. +--! @param a public.json Left operand (encrypted payload). +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.json, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root public.json-to-jsonb comparisons. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-public.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +--! @file v3/sem/ore_cllw/operators.sql +--! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. +--! +--! Each backing function reduces to a single SELECT over +--! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold +--! it through to functional-index matching. The inner comparator is plpgsql +--! (per-byte loop) and is not inlined — fine for index *match*. +--! +--! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, +--! not a hash; there is no merge-joinable opclass on the other side. +--! @see eql_v3_internal.compare_ore_cllw_term + +--! @brief Equality backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 +$$; + +--! @brief Not-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are not equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 +$$; + +--! @brief Less-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 +$$; + +--! @brief Greater-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 +$$; + + +CREATE OPERATOR public.= ( + FUNCTION = eql_v3_internal.ore_cllw_eq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +CREATE OPERATOR public.<> ( + FUNCTION = eql_v3_internal.ore_cllw_neq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +CREATE OPERATOR public.< ( + FUNCTION = eql_v3_internal.ore_cllw_lt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +CREATE OPERATOR public.<= ( + FUNCTION = eql_v3_internal.ore_cllw_lte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +CREATE OPERATOR public.> ( + FUNCTION = eql_v3_internal.ore_cllw_gt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +CREATE OPERATOR public.>= ( + FUNCTION = eql_v3_internal.ore_cllw_gte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; + +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; + +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry public.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for public.jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `oc` (CLLW ORE). The two byte distributions are disjoint +--! by construction, so byte equality on the coalesce is unambiguous. Canonical +--! equality extractor used by `=` / `<>` on jsonb_entry. +--! +--! @param entry public.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts public.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry public.jsonb_entry +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. +--! @see eql_v3.has_ore_cllw +CREATE FUNCTION eql_v3.ore_cllw(entry public.jsonb_entry) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +--! @brief Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry public.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 'oc' IS NOT NULL +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @brief Extract the sv element array as raw jsonb[]. +--! +--! Returns the elements of `sv` (or a single-element array wrapping the value +--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of sv elements. +CREATE FUNCTION eql_v3.ste_vec(val jsonb) + RETURNS jsonb[] + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb; + ary jsonb[]; + BEGIN + IF val ? 'sv' THEN + sv := val->'sv'; + ELSE + sv := jsonb_build_array(val); + END IF; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). +--! @param val jsonb encrypted EQL payload +--! @return boolean True if `a` is present and true. +CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'a' THEN + RETURN (val->>'a')::boolean; + END IF; + RETURN false; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, oc, op) per sv element. +--! +--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can +--! compare for containment. Use for GIN indexes and containment queries. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of objects with only deterministic fields. +CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +RETURNS jsonb[] +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT ARRAY( + SELECT jsonb_object_agg(kv.key, kv.value) + FROM jsonb_array_elements( + CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END + ) AS elem, + LATERAL jsonb_each(elem) AS kv(key, value) + WHERE kv.key IN ('s', 'hm', 'oc', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @brief GIN-indexable containment check: does `a` contain all of `b`? +--! @param a jsonb Container payload. +--! @param b jsonb Search payload. +--! @return boolean True if a contains all deterministic elements of b. +--! @note Public raw-`jsonb[]` containment helper over the extracted +--! deterministic fields — the function-form entrypoint for containment on +--! platforms without operator support (Supabase/PostgREST). The typed +--! `public.json` `@>` operator does NOT call this function — it binds to +--! `eql_v3.ste_vec_contains` instead — but both agree on the result (a +--! parity test pins this). Also the documented GIN index expression +--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @brief GIN-indexable "is contained by" check. +--! @param a jsonb Payload to check. +--! @param b jsonb Container payload. +--! @return boolean True if all elements of a are contained in b. +--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form +--! entrypoint for `<@` on platforms without operator support. The typed +--! `public.json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! but both agree on the result. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and oc byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. The +--! negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; + + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::public.jsonb_entry) = eql_v3.eq_term(b::public.jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @param a public.json Container. +--! @param b public.json Elements to find. +--! @return boolean True if all elements of b are contained in a. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.json, b public.json) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one jsonb_entry row per matching encrypted element. Returns empty +--! set on no match. It deliberately does not wrap multiple matches as an +--! public.json document, because the root document domain requires an `sv` +--! array and single leaves belong to public.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.jsonb_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return public.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ + +--! @brief Get the length of an encrypted JSONB array. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return integer Number of elements. +--! @throws Exception 'cannot get array length of a non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) + RETURNS integer + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF eql_v3_internal.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; + + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF public.jsonb_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.jsonb_entry + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + meta jsonb; + item jsonb; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::public.jsonb_entry; + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract elements of an encrypted JSONB array as ciphertext text. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF text One ciphertext per element. +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) + RETURNS SETOF text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over public.jsonb_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW ORE (`oc`) term, so the extremum is picked by comparing +--! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. Same STRICT + PARALLEL SAFE shape as the +--! generated scalar `min`/`max` so partial/parallel aggregation is available on +--! large GROUP BY workloads. +--! +--! Per the encrypted-domain footgun rules the state functions are +--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would +--! be inlinable and the planner could elide it. +--! +--! @note **Only `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` +--! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a +--! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `oc`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and +--! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive +--! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side +--! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated +--! row is `oc`-less. An all-`oc`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. + +--! @brief State function for min on public.jsonb_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly greater. + IF state_ore IS NULL OR value_ore < state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.jsonb_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly lesser. + IF state_ore IS NULL OR value_ore > state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); + +--! @file v3/sem/ore_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/jsonb/operators.sql +--! @brief Operators on public.json and public.jsonb_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns jsonb_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::text`). +--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> text` +--! operator and silently returns native jsonb semantics (a root-key lookup, +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.json` +--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the +--! native base-type operator wins the exact-match tiebreak. This is intrinsic to +--! the domain type-kind and applies to the native-jsonb blockers too. See +--! the "Typed operands" caveat in docs/reference/json-support.md. +--! +--! @param e public.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector text) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT ( + eql_v3.meta_data(e) || + jsonb_path_query_first( + e, + '$.sv[*] ? (@.s == $sel)'::jsonpath, + jsonb_build_object('sel', selector) + ) + )::public.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector integer) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE + WHEN eql_v3_internal.is_ste_vec_array(e) THEN + -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(public.json, text)` operator does NOT capture a bare + -- untyped literal. The cast documents that intent and guards the `-> selector` + -- (integer) hop from ever resolving to the v3 `->(public.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! Intentional v2 parity: this serializes the entire matched jsonb_entry +--! object as JSON text. It does not decrypt or return scalar plaintext like +--! native `jsonb ->>`. +--! @param e public.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=public.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=public.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a public.json Container. +--! @param b public.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.json +); + +--! @brief @> contains operator with an jsonb_query needle. +--! +--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a +--! functional GIN index on the same expression engages. +--! +--! @param a public.json Container. +--! @param b public.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.jsonb_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.jsonb_query +); + +--! @brief @> contains operator with a single jsonb_entry needle. +--! +--! Wraps the entry into a single-element sv array (stripping `c`) and reduces +--! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. +--! +--! @param a public.json Container. +--! @param b public.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.jsonb_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a public.json Contained value. +--! @param b public.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.json, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a public.jsonb_query Query payload. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_query, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_query, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a public.jsonb_entry Single entry. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_entry, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_entry, + RIGHTARG=public.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) +$$; + +-- Intentionally no HASHES / MERGES here. PostgreSQL requires a hash-joinable +-- operator to appear in a compatible hash opfamily, and a merge-joinable +-- operator to appear as equality in a compatible btree opfamily. jsonb_entry +-- equality is based on eql_v3.eq_term(entry), not raw jsonb/domain equality, so +-- adding only the flags would be unsound. Join/group/dedup on +-- eql_v3.eq_term(doc -> ''::text) unless a jsonb_entry opfamily with +-- eq_term-compatible hash/sort semantics is added. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) +$$; + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_query_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.bigint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.bigint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq_query IS 'EQL bigint query operand (equality)'; + + --! @brief Query-operand domain public.bigint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope_query IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.bigint_eq. + +--! @brief Index extractor for public.bigint_eq. +--! @param a public.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector text) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector integer) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_eq) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for public.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_functions.sql +--! @brief Functions for public.bigint_eq_query. + +--! @brief Index extractor for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_operators.sql +--! @brief Operators for public.bigint_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.bigint. + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector text) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector integer) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for public.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.bigint_ord. + +--! @brief Index extractor for public.bigint_ord. +--! @param a public.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector text) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector integer) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.bigint_ord_ope. + +--! @brief Index extractor for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector text) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector integer) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ope) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ope. + +--! @brief State function for min on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_functions.sql +--! @brief Functions for public.bigint_ord_ope_query. + +--! @brief Index extractor for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_operators.sql +--! @brief Operators for public.bigint_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql +--! @brief Aggregates for public.bigint_ord. + +--! @brief State function for min on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.min(public.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.max(public.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.bigint_ord_ore. + +--! @brief Index extractor for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector text) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector integer) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ore) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ore. + +--! @brief State function for min on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_functions.sql +--! @brief Functions for public.bigint_ord_ore_query. + +--! @brief Index extractor for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_operators.sql +--! @brief Operators for public.bigint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_functions.sql +--! @brief Functions for public.bigint_ord_query. + +--! @brief Index extractor for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_operators.sql +--! @brief Operators for public.bigint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain public.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.boolean. + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector text) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector integer) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.boolean) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for public.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_query_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.date_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.date_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_eq_query IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain public.date_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ore_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ope_query IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain public.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date IS 'EQL encrypted date (storage only)'; + + --! @brief Encrypted domain public.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_eq IS 'EQL encrypted date (equality)'; + + --! @brief Encrypted domain public.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ope IS 'EQL encrypted date (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.date_eq. + +--! @brief Index extractor for public.date_eq. +--! @param a public.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector text) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector integer) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_eq) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for public.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_functions.sql +--! @brief Functions for public.date_eq_query. + +--! @brief Index extractor for public.date_eq_query. +--! @param a public.date_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_operators.sql +--! @brief Operators for public.date_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.date. + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector text) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector integer) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for public.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.date_ord. + +--! @brief Index extractor for public.date_ord. +--! @param a public.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector text) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector integer) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.date_ord_ope. + +--! @brief Index extractor for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector text) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector integer) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ope) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for public.date_ord_ope. + +--! @brief State function for min on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.min(public.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.max(public.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_query_functions.sql +--! @brief Functions for public.date_ord_ope_query. + +--! @brief Index extractor for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_query_operators.sql +--! @brief Operators for public.date_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for public.date_ord. + +--! @brief State function for min on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.min(public.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.max(public.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.date_ord_ore. + +--! @brief Index extractor for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector text +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector text) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector integer +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector integer) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param selector public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ore) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param selector public.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b public.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for public.date_ord_ore. + +--! @brief State function for min on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.min(public.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.max(public.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_query_functions.sql +--! @brief Functions for public.date_ord_ore_query. + +--! @brief Index extractor for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_query_operators.sql +--! @brief Operators for public.date_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_query_functions.sql +--! @brief Functions for public.date_ord_query. + +--! @brief Index extractor for public.date_ord_query. +--! @param a public.date_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_query_operators.sql +--! @brief Operators for public.date_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_query_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.double_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.double_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_eq_query IS 'EQL double query operand (equality)'; + + --! @brief Query-operand domain public.double_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ore_query IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain public.double_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_query IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain public.double_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ope_query IS 'EQL double query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. + +DO $$ +BEGIN + --! @brief Encrypted domain public.double. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double IS 'EQL encrypted double (storage only)'; + + --! @brief Encrypted domain public.double_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_eq IS 'EQL encrypted double (equality)'; + + --! @brief Encrypted domain public.double_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.double_ord IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ope IS 'EQL encrypted double (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.double_eq. + +--! @brief Index extractor for public.double_eq. +--! @param a public.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.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 public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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.double_eq) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.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 public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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.double_eq) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector text +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector text) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector integer +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector integer) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param selector public.double_eq +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_eq) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param selector public.double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b public.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for public.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_functions.sql +--! @brief Functions for public.double_eq_query. + +--! @brief Index extractor for public.double_eq_query. +--! @param a public.double_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.double_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq_query, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.double_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq_query, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_operators.sql +--! @brief Operators for public.double_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.double. + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector text +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector text) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector integer +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector integer) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param selector public.double +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param selector public.double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double, b public.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for public.double. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for public.double_ord. + +--! @brief Index extractor for public.double_ord. +--! @param a public.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector text) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector integer) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for public.double_ord_ope. + +--! @brief Index extractor for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector text +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector text) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector integer +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector integer) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param selector public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ope) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param selector public.double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b public.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for public.double_ord_ope. + +--! @brief State function for min on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.double_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.min(public.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.double_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.max(public.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_query_functions.sql +--! @brief Functions for public.double_ord_ope_query. + +--! @brief Index extractor for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_query_operators.sql +--! @brief Operators for public.double_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for public.double_ord. + +--! @brief State function for min on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.double_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.min(public.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.double_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.max(public.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.double_ord_ore. + +--! @brief Index extractor for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector text +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector text) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector integer +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector integer) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param selector public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ore) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param selector public.double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b public.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for public.double_ord_ore. + +--! @brief State function for min on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.min(public.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.max(public.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_query_functions.sql +--! @brief Functions for public.double_ord_ore_query. + +--! @brief Index extractor for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_query_operators.sql +--! @brief Operators for public.double_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_query_functions.sql +--! @brief Functions for public.double_ord_query. + +--! @brief Index extractor for public.double_ord_query. +--! @param a public.double_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_query_operators.sql +--! @brief Operators for public.double_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_query_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.integer_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.integer_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_eq_query IS 'EQL integer query operand (equality)'; + + --! @brief Query-operand domain public.integer_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ore_query IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain public.integer_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_query IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain public.integer_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ope_query IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain public.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer IS 'EQL encrypted integer (storage only)'; + + --! @brief Encrypted domain public.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_eq IS 'EQL encrypted integer (equality)'; + + --! @brief Encrypted domain public.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.integer_eq. + +--! @brief Index extractor for public.integer_eq. +--! @param a public.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.integer_eq) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.integer_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.integer_eq) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.integer_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector text +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector text) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector integer +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector integer) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param selector public.integer_eq +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_eq) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param selector public.integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b public.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for public.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_functions.sql +--! @brief Functions for public.integer_eq_query. + +--! @brief Index extractor for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_operators.sql +--! @brief Operators for public.integer_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.integer. + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector text +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector text) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector integer +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param selector public.integer +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param selector public.integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b public.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for public.integer. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.integer_ord. + +--! @brief Index extractor for public.integer_ord. +--! @param a public.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector text) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector integer) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.integer_ord_ope. + +--! @brief Index extractor for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector text +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector text) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector integer +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector integer) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param selector public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ope) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param selector public.integer_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for public.integer_ord_ope. + +--! @brief State function for min on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_query_functions.sql +--! @brief Functions for public.integer_ord_ope_query. + +--! @brief Index extractor for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_query_operators.sql +--! @brief Operators for public.integer_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for public.integer_ord. + +--! @brief State function for min on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.integer_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.min(public.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.integer_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.max(public.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.integer_ord_ore. + +--! @brief Index extractor for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector text +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector text) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector integer +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector integer) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param selector public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ore) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param selector public.integer_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for public.integer_ord_ore. + +--! @brief State function for min on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.integer_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.integer_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_query_functions.sql +--! @brief Functions for public.integer_ord_ore_query. + +--! @brief Index extractor for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_query_operators.sql +--! @brief Operators for public.integer_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_query_functions.sql +--! @brief Functions for public.integer_ord_query. + +--! @brief Index extractor for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_query_operators.sql +--! @brief Operators for public.integer_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_query_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.numeric_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.numeric_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_eq_query IS 'EQL numeric query operand (equality)'; + + --! @brief Query-operand domain public.numeric_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_ore_query IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain public.numeric_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_query IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain public.numeric_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_ope_query IS 'EQL numeric query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain public.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric IS 'EQL encrypted numeric (storage only)'; + + --! @brief Encrypted domain public.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_eq IS 'EQL encrypted numeric (equality)'; + + --! @brief Encrypted domain public.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for public.numeric_eq. + +--! @brief Index extractor for public.numeric_eq. +--! @param a public.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.numeric_eq) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.numeric_eq) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector text +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector text) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector integer +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector integer) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param selector public.numeric_eq +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_eq) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param selector public.numeric_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b public.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for public.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_query_functions.sql +--! @brief Functions for public.numeric_eq_query. + +--! @brief Index extractor for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_query_operators.sql +--! @brief Operators for public.numeric_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.numeric. + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector text +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector text) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector integer +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector integer) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param selector public.numeric +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param selector public.numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b public.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for public.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.numeric_ord. + +--! @brief Index extractor for public.numeric_ord. +--! @param a public.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector text +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector text) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector integer +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector integer) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param selector public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param selector public.numeric_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b public.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.numeric_ord_ope. + +--! @brief Index extractor for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector text +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector text) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector integer +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector integer) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param selector public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ope) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param selector public.numeric_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ope. + +--! @brief State function for min on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_query_functions.sql +--! @brief Functions for public.numeric_ord_ope_query. + +--! @brief Index extractor for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_query_operators.sql +--! @brief Operators for public.numeric_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for public.numeric_ord. + +--! @brief State function for min on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.min(public.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.max(public.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.numeric_ord_ore. + +--! @brief Index extractor for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector text +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector text) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector integer +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector integer) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param selector public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ore) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param selector public.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ore. + +--! @brief State function for min on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_functions.sql +--! @brief Functions for public.numeric_ord_ore_query. + +--! @brief Index extractor for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_operators.sql +--! @brief Operators for public.numeric_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_query_functions.sql +--! @brief Functions for public.numeric_ord_query. + +--! @brief Index extractor for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_query_operators.sql +--! @brief Operators for public.numeric_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_query_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.real_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.real_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_eq_query IS 'EQL real query operand (equality)'; + + --! @brief Query-operand domain public.real_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ore_query IS 'EQL real query operand (equality, ordering)'; + + --! @brief Query-operand domain public.real_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_query IS 'EQL real query operand (equality, ordering)'; + + --! @brief Query-operand domain public.real_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ope_query IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. + +DO $$ +BEGIN + --! @brief Encrypted domain public.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real IS 'EQL encrypted real (storage only)'; + + --! @brief Encrypted domain public.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_eq IS 'EQL encrypted real (equality)'; + + --! @brief Encrypted domain public.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ope IS 'EQL encrypted real (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.real_eq. + +--! @brief Index extractor for public.real_eq. +--! @param a public.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.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 public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.real_eq) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.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 public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.real_eq) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector text +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector text) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector integer +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector integer) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param selector public.real_eq +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_eq) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param selector public.real_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b public.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.real_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_query_functions.sql +--! @brief Functions for public.real_eq_query. + +--! @brief Index extractor for public.real_eq_query. +--! @param a public.real_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.real_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq_query, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.real_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq_query, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_query_operators.sql +--! @brief Operators for public.real_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.real. + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector text +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector text) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector integer +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector integer) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param selector public.real +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param selector public.real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real, b public.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.real. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.real_ord. + +--! @brief Index extractor for public.real_ord. +--! @param a public.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector text) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector integer) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.real_ord_ope. + +--! @brief Index extractor for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector text) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector integer) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ope) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.real_ord_ope. + +--! @brief State function for min on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.min(public.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.max(public.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_query_functions.sql +--! @brief Functions for public.real_ord_ope_query. + +--! @brief Index extractor for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_query_operators.sql +--! @brief Operators for public.real_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.real_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.real_ord. + +--! @brief State function for min on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.min(public.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.max(public.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.real_ord_ore. + +--! @brief Index extractor for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector text +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector text) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector integer +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector integer) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param selector public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ore) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param selector public.real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b public.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.real_ord_ore. + +--! @brief State function for min on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.min(public.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.max(public.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_functions.sql +--! @brief Functions for public.real_ord_ore_query. + +--! @brief Index extractor for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_operators.sql +--! @brief Operators for public.real_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_query_functions.sql +--! @brief Functions for public.real_ord_query. + +--! @brief Index extractor for public.real_ord_query. +--! @param a public.real_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_query_operators.sql +--! @brief Operators for public.real_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_query_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.smallint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.smallint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_eq_query IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain public.smallint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ore_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ope_query IS 'EQL smallint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint IS 'EQL encrypted smallint (storage only)'; + + --! @brief Encrypted domain public.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.smallint_eq. + +--! @brief Index extractor for public.smallint_eq. +--! @param a public.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.smallint_eq) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.smallint_eq) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector text) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector integer) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_eq) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_query_functions.sql +--! @brief Functions for public.smallint_eq_query. + +--! @brief Index extractor for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_query_operators.sql +--! @brief Operators for public.smallint_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.smallint. + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector text +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector text) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector integer +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector integer) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param selector public.smallint +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param selector public.smallint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b public.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for public.smallint_ord. + +--! @brief Index extractor for public.smallint_ord. +--! @param a public.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector text) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector integer) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.smallint_ord_ope. + +--! @brief Index extractor for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector text) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector integer) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ope) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ope. + +--! @brief State function for min on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_query_functions.sql +--! @brief Functions for public.smallint_ord_ope_query. + +--! @brief Index extractor for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_query_operators.sql +--! @brief Operators for public.smallint_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.smallint_ord. + +--! @brief State function for min on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.min(public.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.max(public.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for public.smallint_ord_ore. + +--! @brief Index extractor for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector text) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector integer) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ore) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.smallint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ore. + +--! @brief State function for min on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_query_functions.sql +--! @brief Functions for public.smallint_ord_ore_query. + +--! @brief Index extractor for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_query_operators.sql +--! @brief Operators for public.smallint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_query_functions.sql +--! @brief Functions for public.smallint_ord_query. + +--! @brief Index extractor for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_query_operators.sql +--! @brief Operators for public.smallint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_query_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.text_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.text_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_eq_query IS 'EQL text query operand (equality)'; + + --! @brief Query-operand domain public.text_match_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_match_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_match_query IS 'EQL text query operand (containment)'; + + --! @brief Query-operand domain public.text_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ore_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ope_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_search_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_search_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_search_query IS 'EQL text query operand (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain public.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text IS 'EQL encrypted text (storage only)'; + + --! @brief Encrypted domain public.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_eq IS 'EQL encrypted text (equality)'; + + --! @brief Encrypted domain public.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_match IS 'EQL encrypted text (containment)'; + + --! @brief Encrypted domain public.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_search IS 'EQL encrypted text (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.text_eq. + +--! @brief Index extractor for public.text_eq. +--! @param a public.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_eq) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_eq) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector text +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector text) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector integer +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector integer) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param selector public.text_eq +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_eq) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param selector public.text_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b public.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_query_functions.sql +--! @brief Functions for public.text_eq_query. + +--! @brief Index extractor for public.text_eq_query. +--! @param a public.text_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_query_operators.sql +--! @brief Operators for public.text_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.text. + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector integer) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.text_match. + +--! @brief Index extractor for public.text_match. +--! @param a public.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_match) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_match) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector text) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector integer) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_match) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.text_match. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_functions.sql +--! @brief Functions for public.text_match_query. + +--! @brief Index extractor for public.text_match_query. +--! @param a public.text_match_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_operators.sql +--! @brief Operators for public.text_match_query. + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.text. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.text_ord. + +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector text +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector text) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector integer +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector integer) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param selector public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param selector public.text_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b public.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.text_ord_ope. + +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector text +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector text) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector integer +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector integer) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param selector public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ope) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param selector public.text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b public.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.text_ord_ope. + +--! @brief State function for min on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.min(public.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.max(public.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_functions.sql +--! @brief Functions for public.text_ord_ope_query. + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_operators.sql +--! @brief Operators for public.text_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.text_ord. + +--! @brief State function for min on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.min(public.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.max(public.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.text_ord_ore. + +--! @brief Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector text) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector integer) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ore) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.text_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.text_ord_ore. + +--! @brief State function for min on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.min(public.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.max(public.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_query_functions.sql +--! @brief Functions for public.text_ord_ore_query. + +--! @brief Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_query_operators.sql +--! @brief Operators for public.text_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_query_functions.sql +--! @brief Functions for public.text_ord_query. + +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_query_operators.sql +--! @brief Operators for public.text_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.text_search. + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector text) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector integer) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_search) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = public.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.text_search. + +--! @brief State function for min on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.min(public.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.max(public.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_query_functions.sql +--! @brief Functions for public.text_search_query. + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_query_operators.sql +--! @brief Operators for public.text_search_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_query_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.timestamp_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.timestamp_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq_query IS 'EQL timestamp query operand (equality)'; + + --! @brief Query-operand domain public.timestamp_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope_query IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain public.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp IS 'EQL encrypted timestamp (storage only)'; + + --! @brief Encrypted domain public.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq IS 'EQL encrypted timestamp (equality)'; + + --! @brief Encrypted domain public.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.timestamp_eq. + +--! @brief Index extractor for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector text) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector integer) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_eq) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.timestamp_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_query_functions.sql +--! @brief Functions for public.timestamp_eq_query. + +--! @brief Index extractor for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_query_operators.sql +--! @brief Operators for public.timestamp_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.timestamp. + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector text +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector text) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector integer +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector integer) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param selector public.timestamp +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param selector public.timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b public.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.timestamp. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for public.timestamp_ord. + +--! @brief Index extractor for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector text) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector integer) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for public.timestamp_ord_ope. + +--! @brief Index extractor for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector text +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector text) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector integer +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector integer) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param selector public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param selector public.timestamp_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.timestamp_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ope. + +--! @brief State function for min on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_functions.sql +--! @brief Functions for public.timestamp_ord_ope_query. + +--! @brief Index extractor for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_operators.sql +--! @brief Operators for public.timestamp_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.timestamp_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.timestamp_ord. + +--! @brief State function for min on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.min(public.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.max(public.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.timestamp_ord_ore. + +--! @brief Index extractor for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector text) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector integer) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ore. + +--! @brief State function for min on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_functions.sql +--! @brief Functions for public.timestamp_ord_ore_query. + +--! @brief Index extractor for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_operators.sql +--! @brief Operators for public.timestamp_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_query_functions.sql +--! @brief Functions for public.timestamp_ord_query. + +--! @brief Index extractor for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_query_operators.sql +--! @brief Operators for public.timestamp_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +--! @file pin_search_path_v3.sql +--! @brief Post-install: pin search_path on every eql_v3.* function. +--! +--! 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, including public +--! user-column domains) 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. 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') + 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 = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + ) + -- Comment-marker fallback for hand-written inline-critical extension + -- functions that take no domain argument. + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.pg_description d + WHERE d.objoid = p.oid + AND d.classoid = 'pg_catalog.pg_proc'::regclass + AND d.description LIKE 'eql-inline-critical%' + ) + LOOP + EXECUTE pg_catalog.format( + 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', + fn_oid::regprocedure + ); + END LOOP; +END $$; diff --git a/packages/cli/src/sql/cipherstash-encrypt-v3.sql b/packages/cli/src/sql/cipherstash-encrypt-v3.sql new file mode 100644 index 00000000..56a59e03 --- /dev/null +++ b/packages/cli/src/sql/cipherstash-encrypt-v3.sql @@ -0,0 +1,43339 @@ +--! @file v3/schema.sql +--! @brief EQL v3 schema creation +--! +--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted +--! domains (public.integer, public.bigint, and future scalar domains) live in +--! public so application tables survive EQL schema uninstall. eql_v3 is the +--! public API for index-term extractors, aggregates, AND the operator-backing +--! comparison wrappers +--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment +--! helpers). The wrappers are public because they are the function-form +--! equivalent of every supported operator: platforms without operator support +--! (Supabase/PostgREST calls functions, not operators) invoke them by name. +--! eql_v3_internal houses INTERNAL implementation objects only: the +--! searchable-encrypted-metadata (SEM) index-term types +--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! functions, the unsupported-operator blockers (which only raise), and the +--! aggregate state functions. Together the two schemas are self-contained — +--! they own every type they need and have no runtime dependency on another EQL +--! schema. +--! +--! Drops existing schema if present to support clean reinstallation. +--! +--! @warning DROP SCHEMA CASCADE will remove all objects in the schema +--! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! +--! @note DESIGN DECISION — EQL never grants permissions automatically. This +--! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! access is strictly opt-in. A deployment that exposes EQL to +--! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) +--! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! the functions it needs. This is intentional least-privilege, not an +--! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! part of the public API and normally needs no grant; where a caller +--! reaches an internal object indirectly (a public operator/aggregate +--! whose backing state-fn/blocker lives there), grant it deliberately. + +--! @brief Drop existing EQL v3 schema +--! @warning CASCADE will drop all dependent objects +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/common.sql +--! @brief Common utility functions for the self-contained eql_v3 surface. +--! +--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! one transitive helper it needs without reaching into another schema. The +--! eql_v2 original is unchanged. + +--! @brief Convert JSONB hex array to bytea array +--! @internal +--! +--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array. +--! Used for deserializing binary data (like ORE terms) from JSONB storage. +--! +--! @param val jsonb JSONB array of hex-encoded strings +--! @return bytea[] Array of decoded binary values +--! +--! @note Returns NULL if input is JSON null +--! @note Each array element is hex-decoded to bytea +--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller +--! chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` — +--! both reached exclusively from plpgsql and btree operator-class support +--! contexts, where SQL functions can NEVER be inlined and instead pay the +--! per-call SQL-function executor (measured 3.5x the per-call cost of the +--! plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql +--! caches its plan across calls. The non-array guard preserves the v3 +--! behaviour (returns NULL for a non-array scalar; the v2 plpgsql original +--! raised) — both callers only ever pass an array or JSON null (`val->'ob'`), +--! so the divergence stays unreachable in practice; JSON null and empty +--! array still return NULL exactly as before. +CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +RETURNS bytea[] + IMMUTABLE +AS $$ +DECLARE + result bytea[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(decode(value::text, 'hex')::bytea) + INTO result + FROM jsonb_array_elements_text(val) AS value; + RETURN result; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; +-- AUTOMATICALLY GENERATED FILE +-- Source is src/v3/version.template + +DROP FUNCTION IF EXISTS eql_v3.version(); + +--! @file v3/version.sql +--! @brief EQL version reporting (self-contained eql_v3 surface) +--! +--! This file is auto-generated from src/v3/version.template during build. +--! The DEV placeholder is replaced with the actual release +--! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`, +--! or "DEV" for development builds. + +--! @brief Get the installed EQL version string +--! +--! Returns the version string for the installed EQL library. This value is +--! baked in at build time from the release tag. +--! +--! @return text Version string (e.g. "3.0.0" or "DEV" for development builds) +--! +--! @note Auto-generated during build from src/v3/version.template +--! +--! Example: `SELECT eql_v3.version()` returns the installed version string, +--! e.g. `'3.0.0'` (or `'DEV'` for development builds). +CREATE FUNCTION eql_v3.version() + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT 'DEV'; +$$ LANGUAGE SQL; + +--! @brief Schema-level version marker for obj_description() discoverability +--! +--! Mirrors eql_v3.version() as a comment on the schema so the installed +--! version can also be read via obj_description('eql_v3'::regnamespace). +COMMENT ON SCHEMA eql_v3 IS 'DEV'; + +--! @file v3/sem/ore_block_256/types.sql +--! @brief ORE block index-term types (eql_v3 SEM). +--! +--! 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/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/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)'; + +--! @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/hmac_256/functions.sql +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). +--! +--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and +--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! domains extract from the jsonb payload directly via a cast to the domain. +--! (Doc comments deliberately avoid naming eql_v2 symbols so the +--! self-containment grep stays clean.) + +--! @brief Extract HMAC-SHA256 index term from JSONB payload +--! +--! Inlinable single-statement SQL — the planner can fold this into the calling +--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! (which calls this) engage structurally. +--! +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) + RETURNS eql_v3_internal.hmac_256 + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 +$$; + + +--! @brief Check if JSONB payload contains HMAC-SHA256 index term +--! +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True if 'hm' field is present and non-null +CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) + RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (val ->> 'hm') IS NOT NULL +$$; + +--! @file v3/sem/bloom_filter/types.sql +--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. + +--! @brief Bloom-filter index term: a bit array stored as smallint[]. +--! +--! Backs the `match` capability (`@>` / `<@`) on `eql_v3_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/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 +$$; + +--! @brief EQL lint: detect non-inlinable operator implementation functions +--! +--! Returns one row per violation found in the installed `eql_v3` surface. The +--! Postgres planner can only inline a function during index matching when: +--! +--! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) +--! * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into +--! index expressions) +--! * No `SET` clauses (e.g. `SET search_path = ...`) +--! * Not `SECURITY DEFINER` +--! * Single-statement SELECT body +--! +--! @note The single-statement SELECT body condition is **not yet checked** by +--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE, +--! or any pre-SELECT statement will pass all four implemented checks while +--! remaining non-inlinable. Implementing the check requires walking `prosrc` +--! (or `pg_get_functiondef`); tracked as a follow-up. +--! +--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and +--! the SEM index-term types `eql_v3_internal.ore_block_256`, `eql_v3_internal.ore_cllw`) whose +--! implementation functions fail any of these rules silently fall back to seq +--! scan when the documented functional indexes (`eql_v3.eq_term(col)`, +--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. +--! +--! Severity: +--! `error` — fixable, blocks index matching, ship-blocking. +--! `warning` — likely-fixable, may not block matching but signals intent. +--! `info` — observational; useful for review, not a defect on its own. +--! +--! Categories: +--! `inlinability_language` — implementation function isn't `LANGUAGE sql`. +--! `inlinability_volatility` — implementation function is VOLATILE. +--! `inlinability_set_clause` — implementation function has a `SET` clause. +--! `inlinability_secdef` — implementation function is `SECURITY DEFINER`. +--! `inlinability_transitive` — implementation function is itself inlinable +--! but its body invokes a non-inlinable function +--! (depth 1; the planner can't peek through +--! that boundary). +--! `blocker_language` — encrypted-domain blocker is not LANGUAGE +--! plpgsql. The planner can inline / elide a +--! LANGUAGE sql body when the result is +--! provably unused, silently bypassing the +--! RAISE that the blocker exists to perform. +--! `blocker_strict` — encrypted-domain blocker is STRICT. +--! PostgreSQL skips the body and returns NULL +--! on NULL arguments, silently bypassing the +--! RAISE. +--! `domain_over_domain` — an `eql_v3` encrypted domain is derived from +--! another encrypted domain rather than jsonb. +--! Operators resolve against the ultimate base +--! type, so the derived domain does not +--! inherit the base domain's blocker surface. +--! `domain_opclass` — an operator class is declared FOR TYPE on an +--! `eql_v3` encrypted domain. Opclasses on +--! domains bypass operator resolution; use a +--! functional index on the extractor instead. +--! `schema_placement` — a naked composite or enum TYPE lives in the +--! public `eql_v3` schema. Internal index-term +--! types (e.g. `ore_block_256_term`) belong in +--! `eql_v3_internal`; a composite/enum in +--! `eql_v3` clutters the Supabase Table Builder +--! type picker, which the schema split exists to +--! prevent. Move it to `eql_v3_internal`. +--! +--! @example +--! ``` +--! SELECT severity, category, object_name, message +--! FROM eql_v3.lints() +--! WHERE severity = 'error' +--! ORDER BY category, object_name; +--! ``` +--! +--! @return SETOF record (severity text, category text, object_name text, message text) +CREATE OR REPLACE FUNCTION eql_v3.lints() +RETURNS TABLE ( + severity text, + category text, + object_name text, + message text +) +LANGUAGE sql STABLE +AS $$ + WITH + -- User-column encrypted domains now live in public so application tables + -- survive EQL uninstall. Keep this separate from owned_schemas(): public is + -- not installer-owned, but its EQL jsonb-backed domains are still the domain + -- types whose blockers/operator surfaces the lint must understand. + encrypted_domain_types AS ( + SELECT + dt.oid AS typid + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND bt.typname = 'jsonb' + AND bn.nspname = 'pg_catalog' + AND ( + dn.nspname = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ), + + -- All operators where at least one operand is an EQL-owned type or a public + -- encrypted domain. Limits the scope of the lint to the operator surface + -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends). + eql_operators AS ( + SELECT + op.oid AS oprid, + op.oprname AS opname, + op.oprcode AS implfunc, + op.oprleft::regtype AS lhs, + op.oprright::regtype AS rhs, + op.oprcode::regprocedure AS impl_signature + FROM pg_operator op + WHERE EXISTS ( + SELECT 1 FROM pg_type t + WHERE t.oid IN (op.oprleft, op.oprright) + AND ( + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + OR t.oid IN (SELECT typid FROM encrypted_domain_types) + ) + ) + ), + + -- Cross-join with each operator's implementation function metadata. + -- One row per operator; columns describe the inlinability of the impl. + op_impl AS ( + SELECT + eo.opname, + eo.lhs, + eo.rhs, + eo.implfunc AS impl_oid, + eo.impl_signature::text AS impl_signature, + lang_l.lanname AS lang, + p.provolatile AS volatility, + p.proconfig AS config, + p.prosecdef AS secdef, + p.prosrc AS body + FROM eql_operators eo + JOIN pg_proc p ON p.oid = eo.implfunc + JOIN pg_language lang_l ON lang_l.oid = p.prolang + ), + + -- Encrypted-domain blockers: functions in `eql_v3` whose body contains + -- a blocker marker emitted by the codegen (any of the + -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean + -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the + -- literal `is not supported for` for older path-operator blockers) AND + -- that take at least one encrypted domain over jsonb argument. The argument + -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)` + -- helpers themselves, which contain the marker in their body but are not + -- blockers (they take text arguments, not a domain). + encrypted_domain_blockers AS ( + SELECT + p.oid AS oid, + p.oid::regprocedure::text AS signature, + lang_l.lanname AS lang, + p.proisstrict AS isstrict + FROM pg_catalog.pg_proc p + JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace + JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang + WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + AND (p.prosrc LIKE '%encrypted_domain_unsupported%' + OR p.prosrc LIKE '%is not supported for%') + AND EXISTS ( + SELECT 1 + FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ) + JOIN encrypted_domain_types edt ON edt.typid = arg.typ + ) + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Direct inlinability checks: each row examines one operator's │ + -- │ implementation function and emits a violation if any rule is │ + -- │ broken. Multiple violations on the same function become │ + -- │ multiple rows (developers see every reason it doesn't inline). │ + -- └─────────────────────────────────────────────────────────────────┘ + + SELECT + 'error' AS severity, + 'inlinability_language' AS category, + format('operator %s(%s, %s) -> %s', + opname, lhs, rhs, impl_signature) AS object_name, + format( + 'Operator implementation function is `LANGUAGE %s`; only `LANGUAGE sql` functions can be inlined by the planner. Bare `col %s val` queries fall back to seq scan even when a matching functional index exists.', + lang, opname) AS message + FROM op_impl + WHERE lang <> 'sql' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_volatility', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + 'Operator implementation function is `VOLATILE`. The Postgres planner refuses to inline volatile functions into index expressions, so functional indexes never engage. Mark the function `IMMUTABLE` (or `STABLE` if it depends on session state).', + opname) + FROM op_impl + WHERE volatility = 'v' + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_set_clause', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + format( + 'Operator implementation function has a `SET` clause (e.g. `SET search_path = ...`). Per Postgres function-inlining rules, any `SET` clause blocks inlining. Use schema-qualified identifiers in the body and remove the `SET` clause to allow the planner to inline.') + FROM op_impl + WHERE config IS NOT NULL + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + UNION ALL + + SELECT + 'error', + 'inlinability_secdef', + format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature), + 'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.' + FROM op_impl + WHERE secdef + AND NOT EXISTS ( + SELECT 1 FROM encrypted_domain_blockers b + WHERE b.oid = op_impl.impl_oid + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Transitive inlinability: an operator implementation function │ + -- │ that's itself inlinable can still fail to inline if its body │ + -- │ calls a non-inlinable function. Walk one level via pg_depend. │ + -- │ │ + -- │ Postgres records function-to-function dependencies in │ + -- │ pg_depend with deptype 'n' (normal) when one function references│ + -- │ another in its body — but only at CREATE time and only for │ + -- │ direct calls. This is good enough for v1; deeper transitive │ + -- │ analysis is a follow-up. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'inlinability_transitive', + format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs, + oi.impl_signature), + format( + 'Operator implementation function is inlinable but invokes non-inlinable function `%s` (lang=%s, volatility=%s%s). The chain blocks at depth 1: the planner inlines the outer call but cannot reduce the inner call into an index expression.', + called.proname, + called_lang.lanname, + CASE called.provolatile + WHEN 'i' THEN 'IMMUTABLE' + WHEN 's' THEN 'STABLE' + WHEN 'v' THEN 'VOLATILE' + END, + CASE WHEN called.proconfig IS NOT NULL + THEN ', has SET clause' + ELSE '' END) + FROM op_impl oi + -- Only worth the transitive check if the outer function is otherwise + -- inlinable — otherwise the direct lints above already report it. + JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure + JOIN pg_depend d + ON d.classid = 'pg_proc'::regclass + AND d.objid = outer_p.oid + AND d.refclassid = 'pg_proc'::regclass + AND d.deptype = 'n' + JOIN pg_proc called ON called.oid = d.refobjid + JOIN pg_language called_lang ON called_lang.oid = called.prolang + WHERE oi.lang = 'sql' + AND oi.volatility IN ('i', 's') + AND oi.config IS NULL + AND NOT oi.secdef + AND called.oid <> outer_p.oid + AND ( + called_lang.lanname <> 'sql' + OR called.provolatile = 'v' + OR called.proconfig IS NOT NULL + OR called.prosecdef + ) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Encrypted-domain footguns: blockers exist to RAISE, so they │ + -- │ have inverted inlinability requirements vs operator impls. │ + -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT │ + -- │ blocker returns NULL on NULL args. Both silently re-enable │ + -- │ operators the storage variant is supposed to block. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'blocker_language', + format('function %s', signature), + format( + 'Encrypted-domain blocker is `LANGUAGE %s`; must be `LANGUAGE plpgsql` so the RAISE is opaque to the planner. A `LANGUAGE sql` body is inlinable and may be elided when the result is provably unused, silently re-enabling the operator.', + lang) + FROM encrypted_domain_blockers + WHERE lang <> 'plpgsql' + + UNION ALL + + SELECT + 'error', + 'blocker_strict', + format('function %s', signature), + 'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.' + FROM encrypted_domain_blockers + WHERE isstrict + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain identity: an encrypted-domain must be defined directly │ + -- │ over jsonb. Operators resolve against the ultimate base type, │ + -- │ so domain-over-domain inherits jsonb's operator surface and not │ + -- │ the base domain's blockers. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'domain_over_domain', + format('domain %I.%I', dn.nspname, dt.typname), + format( + 'Domain `%s.%s` is derived from another encrypted-domain `%s.%s` rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain''s operator surface and storage blockers do not engage. Define this domain directly over jsonb.', + dn.nspname, dt.typname, bn.nspname, bt.typname) + FROM pg_catalog.pg_type dt + JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace + JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype + JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace + WHERE dt.typtype = 'd' + AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND bt.typtype = 'd' + AND bt.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Domain opclass: an operator class declared FOR TYPE on an │ + -- │ encrypted-domain bypasses operator resolution at index time. │ + -- │ Use a functional index on the extractor instead. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'domain_opclass', + format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname), + format( + 'Operator class `%s.%s` is declared FOR TYPE `%s.%s`, which is an encrypted-domain type. Opclasses on domains bypass operator resolution. Use a functional index on the extractor (e.g. `%s.eq_term(col)`, `%s.ord_term(col)`) instead.', + cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname) + FROM pg_catalog.pg_opclass oc + JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype + JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace + JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace + WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) + + -- ┌─────────────────────────────────────────────────────────────────┐ + -- │ Schema placement: the public `eql_v3` schema must hold only the │ + -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ + -- │ there is an internal index-term type in the wrong schema — it │ + -- │ clutters the Supabase type picker the split exists to keep clean. │ + -- └─────────────────────────────────────────────────────────────────┘ + + UNION ALL + + SELECT + 'error', + 'schema_placement', + format('type %I.%I', n.nspname, t.typname), + format( + 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.', + n.nspname, t.typname, + CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) + FROM pg_catalog.pg_type t + JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace + WHERE n.nspname = 'eql_v3' + AND t.typtype IN ('c', 'e') + + ORDER BY 1, 2, 3; +$$; + +COMMENT ON FUNCTION eql_v3.lints() IS + 'EQL lint: returns one row per non-inlinable operator implementation. ' + 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' + 'CI-gateable check that all operator implementations on eql_v3 types are ' + 'eligible for planner inlining.'; + +--! @file v3/sem/ore_cllw/types.sql +--! @brief CLLW ORE index term type for STE-vec range queries (eql_v3 SEM) +--! +--! Composite type for CLLW (Copyless Logarithmic Width) Order-Revealing +--! Encryption. The ciphertext is stored in the `oc` field of encrypted data +--! payloads (Standard-mode `ste_vec` elements). Used by the range operators +--! (`<`, `<=`, `>`, `>=`) when an sv element carries an `oc` term. +--! +--! The wire-format `oc` value is a hex string with a leading domain-tag byte +--! (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext. The +--! decoded `bytes` field carries the full byte string including the tag — the +--! comparator is variable-length capable, so numeric and string values within +--! the same column order correctly: the domain tag separates the ranges +--! (numeric < string) and the within-domain comparison falls through to the +--! CLLW per-byte protocol. +--! +--! @note This is a transient type used only during query execution. +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE TYPE eql_v3_internal.ore_cllw AS ( + bytes bytea +); + +--! @file v3/scalars/functions.sql +--! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! +--! Per-domain wrapper functions live in src/v3/scalars//. +--! Blockers in those files delegate to encrypted_domain_unsupported_bool +--! so every domain raises a uniform domain-specific error rather than +--! letting an unsupported operator fall through to native jsonb +--! behaviour. + +--! @brief Shared blocker helper. Raises 'operator X is not supported +--! for TYPE' so unsupported domain operators surface a clear +--! error rather than fall through to native jsonb behaviour. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (=, <, @>, ->, etc.) +--! @return boolean (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning jsonb. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! native operators whose result is jsonb (#>, -, #-, ||), so composed +--! expressions resolve and the body raises rather than failing earlier +--! with a misleading 'operator does not exist' on a boolean result. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>, -, #-, ||, etc.) +--! @return jsonb (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @brief Shared blocker helper returning text. Identical to +--! encrypted_domain_unsupported_bool but typed for blockers shadowing +--! the native #>> operator whose result is text. +--! @param type_name Domain type name (eql_v3.*) +--! @param operator_name Operator symbol (#>>) +--! @return text (never returns; always raises) +CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/types.sql +--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! Three jsonb-backed domains (none over another domain — operators resolve +--! against the ultimate base type jsonb, so the native-jsonb firewall in +--! blockers.sql can attach): +--! - public.json — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.jsonb_entry — a single sv element (returned by `->`). +--! - public.jsonb_query — a containment needle (sv elements, no ciphertext). + +--! @brief Validate a single SteVec entry payload. +--! @internal +--! @param val jsonb Candidate entry payload. +--! @return boolean True when `val` is an sv entry with string `s`, string `c`, +--! and exactly one string deterministic term (`hm` XOR `oc`). +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 's') = 'string' + AND jsonb_typeof(val -> 'c') = 'string' + AND ( + (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'oc')) + OR + (jsonb_typeof(val -> 'oc') = 'string' AND NOT (val ? 'hm')) + ), + false + ) +$$; + +--! @brief Validate a SteVec containment query payload. +--! @internal +--! @param val jsonb Candidate query payload. +--! @return boolean True when `val` is `{"sv":[...]}` and every element carries +--! string `s`, no ciphertext, and exactly one string term (`hm` XOR +--! `oc`). +--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the +--! public.jsonb_query domain CHECK, where a SQL function can never be +--! inlined (and the CHECK itself cannot absorb this body — it needs a +--! subquery over the sv elements, which CHECK constraints forbid). plpgsql +--! caches its plan across calls instead of paying the per-call SQL-function +--! executor on every needle cast. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) + RETURNS boolean + LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +AS $$ +BEGIN + RETURN COALESCE( + jsonb_typeof(val) = 'object' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT COALESCE(( + jsonb_typeof(elem) = 'object' + AND jsonb_typeof(elem -> 's') = 'string' + AND NOT (elem ? 'c') + AND ( + (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'oc')) + OR + (jsonb_typeof(elem -> 'oc') = 'string' AND NOT (elem ? 'hm')) + ) + ), false) + ), + false + ); +END; +$$; + +--! @brief Validate a root SteVec document payload. +--! @internal +--! @param val jsonb Candidate document payload. +--! @return boolean True when `val` is an encrypted document envelope with +--! `v = 3`, `i`, an `sv` array, and valid sv entry elements. +CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT COALESCE( + jsonb_typeof(val) = 'object' + AND val ? 'v' + AND val ->> 'v' = '3' + AND val ? 'i' + AND jsonb_typeof(val -> 'sv') = 'array' + AND NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements( + CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END + ) AS elem + WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + ), + false + ) +$$; + +--! @brief Storage/root domain for an encrypted JSONB column. +--! +--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index +--! metadata). Root `c` is intentionally NOT required — an sv-array root payload +--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv` +--! array, so the domain accepts only SteVec **document** payloads and rejects +--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is +--! what keeps `public.json` a typed document domain rather than a generic +--! encrypted envelope. The firewall in blockers.sql attaches to this domain to +--! stop native jsonb operators from reaching a column value. +--! +--! @note Constructing from inline JSON uses the standard DOMAIN cast: +--! `'{"i":{},"v":3,"sv":[...]}'::public.json`. +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'json' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.json AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.json IS 'EQL encrypted JSONB document (containment, equality, ordering)'; +END +$$; + +--! @brief Domain type for an individual sv element. +--! +--! A single element inside an `sv` array: a JSON object that carries a selector +--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for +--! hash-equality) or `oc` (CLLW ORE, for ordered queries) — they are mutually +--! exclusive. This is the type returned by `->` and accepted by the per-entry +--! extractors `eql_v3.eq_term` / `eql_v3.ore_cllw`. Extra fields (`a`, root +--! `i`/`v` merged in by `->`) are allowed. +--! +--! @see src/v3/jsonb/operators.sql +--! +--! @internal +--! Implementation note (issue #354): the CHECK is an INLINE expression, not a +--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! constraints cannot inline SQL functions, so the function-call form paid +--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle +--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured +--! regression on that scenario; see cipherstash/benches#23). The expression +--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the +--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false) +--! would reject NULL, which `->` returns for a missing selector). Keep the +--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins +--! the equivalence. +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_entry' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_entry AS jsonb + CHECK ( + VALUE IS NULL + OR COALESCE( + jsonb_typeof(VALUE) = 'object' + AND jsonb_typeof(VALUE -> 's') = 'string' + AND jsonb_typeof(VALUE -> 'c') = 'string' + AND ( + (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'oc')) + OR + (jsonb_typeof(VALUE -> 'oc') = 'string' AND NOT (VALUE ? 'hm')) + ), + false + ) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; +END +$$; + +--! @brief Domain type for an STE-vec containment needle. +--! +--! A query-shaped payload `{"sv":[...]}` whose elements carry selector + index +--! term but **never** a ciphertext (`c`). Each element must carry `s` and +--! exactly one deterministic term (`hm` XOR `oc`). Typing the needle this way +--! stops selector-only needles from casting and matching every row via bare +--! `jsonb @>`. +--! +--! @note Construct from inline JSON via the DOMAIN cast: +--! `'{"sv":[{"s":"","hm":""}]}'::public.jsonb_query`. +--! @see eql_v3.to_ste_vec_query +--! +--! @internal +--! Implementation note (issue #354): this CHECK CANNOT be inlined like +--! public.jsonb_entry's — validating the sv elements requires a subquery +--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK +--! constraints forbid subqueries. The validator is plpgsql instead (cached +--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql +--! function — the same finding as issue #353), since this cast sits on the +--! per-query hot path of every containment scenario +--! (`$1::jsonb::public.jsonb_query`). +--! @endinternal +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'jsonb_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.jsonb_query AS jsonb + CHECK ( + public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + ); + END IF; + + COMMENT ON DOMAIN public.jsonb_query IS 'EQL JSONB query operand (containment)'; +END +$$; + +--! @brief Convert a public.json to a jsonb_query needle. +--! +--! Normalises each sv element down to the matching-relevant fields: `s` plus +--! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else) +--! are stripped. This is the canonical needle shape for `@>` containment. +--! Designed for use as a functional GIN index expression: +--! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! +--! @param e public.json Source encrypted payload +--! @return public.jsonb_query Query-shaped needle, sv elements normalised. +--! @see public.jsonb_query +CREATE FUNCTION eql_v3.to_ste_vec_query(e public.json) + RETURNS public.jsonb_query + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT jsonb_build_object( + 'sv', + coalesce( + (SELECT jsonb_agg( + jsonb_strip_nulls( + jsonb_build_object( + 's', elem -> 's', + 'hm', elem -> 'hm', + 'oc', elem -> 'oc' + ) + ) + ) + FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), + '[]'::jsonb + ) + )::public.jsonb_query +$$; + +CREATE CAST (public.json AS public.jsonb_query) + WITH FUNCTION eql_v3.to_ste_vec_query + AS ASSIGNMENT; + +--! @file v3/crypto.sql +--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! +--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! closure lives under src/v3/. Enables the pgcrypto extension which provides +--! cryptographic functions used by the eql_v3 ORE comparison path. +--! +--! Installs pgcrypto into the `extensions` schema (Supabase convention) to +--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto +--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing +--! install in `public` keeps working — and a pre-existing install anywhere else +--! will be rejected at install time. The body is idempotent +--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it +--! alongside the eql_v2 copy in a combined install is safe. +--! +--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes() + +--! @brief Create extensions schema (Supabase convention) +CREATE SCHEMA IF NOT EXISTS extensions; + +--! @brief Enable pgcrypto extension and validate its schema +DO $$ +DECLARE + pgcrypto_schema name; +BEGIN + IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN + CREATE EXTENSION pgcrypto WITH SCHEMA extensions; + END IF; + + SELECT n.nspname INTO pgcrypto_schema + FROM pg_extension e + JOIN pg_namespace n ON n.oid = e.extnamespace + WHERE e.extname = 'pgcrypto'; + + IF pgcrypto_schema = 'extensions' THEN + -- expected location, nothing to say + NULL; + ELSIF pgcrypto_schema = 'public' THEN + RAISE NOTICE + 'pgcrypto is installed in the `public` schema. EQL works against this layout, ' + 'but Supabase splinter will flag it as `extension_in_public`. Move it with: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions'; + ELSE + RAISE EXCEPTION + 'pgcrypto is installed in schema `%`, which is not on the EQL function search_path ' + '(pg_catalog, extensions, public). EQL cryptographic operations would fail at ' + 'runtime. Relocate the extension before installing EQL: ' + 'ALTER EXTENSION pgcrypto SET SCHEMA extensions', + pgcrypto_schema; + END IF; +END $$; + +--! @file v3/sem/ore_block_256/functions.sql +--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! +--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The +--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array +--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and +--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments +--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays +--! clean.) + +--! @brief Convert JSONB array to ORE block composite type +--! @internal +--! @param val jsonb Array of hex-encoded ORE block terms +--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller +--! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached +--! from an inlinable context — as `LANGUAGE sql` it paid the per-call +--! SQL-function executor on every compared value in the opclass hot path +--! (measured: +43% on ORE ordered scans vs the plpgsql form). The +--! non-array guard preserves the v3 behaviour (returns NULL for a +--! non-array scalar; the v2 plpgsql original raised); the caller only +--! reaches this when `has_ore_block_256(val)` is true, which requires +--! `val->'ob'` to be a JSON array, so that branch stays unreachable. +--! An empty array (`ob: []`, what encrypting the empty string `""` produces) +--! yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms. +--! The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and +--! NULL terms make the comparator return NULL (so an empty-text row silently +--! drops out of ordered queries). An empty array instead engages the +--! comparator's `cardinality = 0` guard, which sorts empty BEFORE every +--! non-empty term. See issue #262 (pinned by T7). +CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE +AS $$ +DECLARE + terms eql_v3_internal.ore_block_256_term[]; +BEGIN + IF val IS NULL OR jsonb_typeof(val) != 'array' THEN + RETURN NULL; + END IF; + SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + INTO terms + FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b; + -- plpgsql pitfall: `SELECT INTO ` assigns the + -- select-list columns FIELD-WISE into the variable — return the row + -- constructor directly instead. The COALESCE stays load-bearing for the + -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and + -- the comparator needs an EMPTY terms array, not NULL terms. + RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256; +END; +$$ LANGUAGE plpgsql; + +--! @internal Keep the inline-critical marker so the post-install +--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a +--! plpgsql function forces per-call configuration switching — measurable on a +--! helper invoked per compared value in the ore_block_256 opclass hot path. +--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the +--! structural skip in tasks/pin_search_path_v3.sql does not recognise it; +--! this marker is the documented manual opt-in. +COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS + 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; + + +--! @brief Extract ORE block index term from JSONB payload +--! @param val jsonb containing encrypted EQL payload +--! @return eql_v3_internal.ore_block_256 ORE block index term +--! @throws Exception if 'ob' field is missing +CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) + RETURNS eql_v3_internal.ore_block_256 + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without + -- entering the body, so no explicit `val IS NULL` guard is needed. + IF eql_v3_internal.has_ore_block_256(val) THEN + RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + END IF; + RAISE 'Expected an ore index (ob) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Check if JSONB payload contains an ORE block index term +--! @param val jsonb containing encrypted EQL payload +--! @return boolean True only if the 'ob' field is present and is a JSON array +--! @note A well-formed ORE index term is always a JSON array of block terms, so +--! this guard treats a present-but-non-array `ob` (a scalar or object) as +--! absent. That makes the extractor `ore_block_256(val)` RAISE on a +--! structurally invalid `ob` payload at the boundary instead of silently +--! degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The +--! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so +--! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) +--! both remain `false`. +CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false); + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare two ORE block terms using cryptographic comparison +--! @internal +--! @param a eql_v3_internal.ore_block_256_term First ORE term +--! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @return integer -1 if a < b, 0 if a = b, 1 if a > b +--! @throws Exception if ciphertexts are different lengths +--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` +--! overloads all are). This deliberately diverges from the v2 originals, +--! which carry no volatility marker and so default to `VOLATILE`. The +--! comparison is deterministic — its only crypto call, pgcrypto `encrypt()`, +--! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the +--! planner fold/cache these in ordering and index contexts. NOT `STRICT`: +--! the NULL-handling branches below are load-bearing for the array overload. +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) + RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + eq boolean := true; + unequal_block smallint := 0; + hash_key bytea; + data_block bytea; + encrypt_block bytea; + target_block bytea; + + left_block_size CONSTANT smallint := 16; + right_block_size CONSTANT smallint := 32; + + -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8. + -- Wire format per term: + -- [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ] + -- octet_length = 17*N + 16 + 32*N = 49*N + 16 => N = (octet_length - 16) / 49 + -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric + -- (N=14, 702B) with one comparator. + n integer; + left_offset integer; -- ordinal offset of the first left block (1 + N PRP bytes) + right_offset integer; -- ordinal start of the right CT (= total left CT length = 17*N) + + indicator smallint := 0; + BEGIN + IF a IS NULL AND b IS NULL THEN + RETURN 0; + END IF; + + IF a IS NULL THEN + RETURN -1; + END IF; + + IF b IS NULL THEN + RETURN 1; + END IF; + + IF bit_length(a.bytes) != bit_length(b.bytes) THEN + RAISE EXCEPTION 'Ciphertexts are different lengths'; + END IF; + + -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The + -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0 + -- and derives N = 0, which would fall through to the all-blocks-equal path + -- and return 0 instead of raising. The `<= 16` clause is load-bearing. + IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN + RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes); + END IF; + + n := (octet_length(a.bytes) - 16) / 49; + left_offset := 1 + n; -- left blocks begin right after the N PRP bytes + right_offset := 17 * n; -- right CT begins right after the 17*N-byte left CT + + FOR block IN 0..n-1 LOOP + -- Compare each PRP byte (the first N bytes) and its 16-byte left block. + IF + substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1) + OR substr(a.bytes, left_offset + left_block_size * block, left_block_size) != substr(b.bytes, left_offset + left_block_size * block, left_block_size) + THEN + IF eq THEN + unequal_block := block; + END IF; + eq = false; + END IF; + END LOOP; + + IF eq THEN + RETURN 0::integer; + END IF; + + -- Hash key is the IV from the right CT of b. + hash_key := substr(b.bytes, right_offset + 1, 16); + + -- First right block is at right_offset + nonce_size (ordinally indexed). + target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size); + + data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size); + + encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb'); + + indicator := ( + get_bit( + encrypt_block, + 0 + ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2; + + IF indicator = 1 THEN + RETURN 1::integer; + ELSE + RETURN -1::integer; + END IF; + END; +$$ LANGUAGE plpgsql; + + +--! @brief Compare arrays of ORE block terms recursively +--! @internal +--! @param a eql_v3_internal.ore_block_256_term[] First array +--! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @return integer -1/0/1, or NULL if either array is NULL +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + cmp_result integer; + BEGIN + IF a IS NULL OR b IS NULL THEN + RETURN NULL; + END IF; + + IF cardinality(a) = 0 AND cardinality(b) = 0 THEN + RETURN 0; + END IF; + + IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN + RETURN -1; + END IF; + + IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN + RETURN 1; + END IF; + + cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + + IF cmp_result = 0 THEN + RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + END IF; + + RETURN cmp_result; + END +$$ LANGUAGE plpgsql; + + +--! @brief Compare ORE block composite types +--! @internal +--! @param a eql_v3_internal.ore_block_256 First ORE block +--! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @return integer -1/0/1 +CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS integer + IMMUTABLE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + END +$$ LANGUAGE plpgsql; + +--! @file v3/sem/ore_cllw/functions.sql +--! @brief CLLW ORE index-term extraction and comparison (eql_v3 SEM). + +--! @brief Extract CLLW ORE index term from raw jsonb +--! +--! Returns the CLLW ORE ciphertext from the `oc` field of a single sv element +--! supplied as raw jsonb. Inlinable single-statement SQL — the planner folds +--! the body into the calling query. +--! +--! **Missing-`oc` semantics**: returns SQL-level NULL (not a composite with +--! NULL bytes) when `oc` is absent, so btree's NULL handling filters those +--! rows from range queries. +--! +--! @param val jsonb An object carrying an `oc` field +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL +--! when the `oc` field is absent. +--! @see eql_v3_internal.has_ore_cllw +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw(val jsonb) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN val ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(val ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +COMMENT ON FUNCTION eql_v3_internal.ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW extractor; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a raw jsonb value contains a CLLW ORE index term +--! @param val jsonb An object that may carry an `oc` field +--! @return boolean True if `oc` field is present and non-null +CREATE FUNCTION eql_v3_internal.has_ore_cllw(val jsonb) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT val ->> 'oc' IS NOT NULL +$$; + +COMMENT ON FUNCTION eql_v3_internal.has_ore_cllw(jsonb) IS + 'eql-inline-critical: raw-jsonb CLLW presence helper; must stay inlinable (unpinned search_path)'; + +--! @brief CLLW per-byte comparison helper +--! @internal +--! +--! Byte-by-byte comparison implementing the CLLW order-revealing protocol. +--! Identify the index of the first differing byte; if `(y_byte + 1) == x_byte` +--! (mod 256) there, then x > y; otherwise x < y. Equal inputs return 0. Inputs +--! MUST be the same length (the caller guarantees this). Stays `LANGUAGE +--! plpgsql` — the per-byte loop can't be a single inlinable SQL expression. +--! +--! @param a bytea First CLLW ciphertext slice +--! @param b bytea Second CLLW ciphertext slice +--! @return integer -1, 0, or 1 +--! @throws Exception if inputs are different lengths +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term_bytes(a bytea, b bytea) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + i INT; + first_diff INT := 0; +BEGIN + + len_a := LENGTH(a); + len_b := LENGTH(b); + + IF len_a != len_b THEN + RAISE EXCEPTION 'ore_cllw index terms are not the same length'; + END IF; + + FOR i IN 1..len_a LOOP + IF first_diff = 0 AND get_byte(a, i - 1) != get_byte(b, i - 1) THEN + first_diff := i; + END IF; + END LOOP; + + IF first_diff = 0 THEN + RETURN 0; + END IF; + + IF ((get_byte(b, first_diff - 1) + 1) & 255) = get_byte(a, first_diff - 1) THEN + RETURN 1; + ELSE + RETURN -1; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @brief Variable-length CLLW ORE term comparison +--! @internal +--! +--! Three-way comparison of two CLLW ORE ciphertext terms of potentially +--! different lengths. Compares the shared prefix via the CLLW per-byte +--! protocol; on equal prefixes, the shorter input sorts first. The leading +--! domain-tag byte makes numeric (`0x00`) sort before string (`0x01`). Stays +--! `LANGUAGE plpgsql` because it dispatches to `compare_ore_cllw_term_bytes`. +--! +--! btree filters NULL composites at the row level, so this should never see a +--! NULL composite under normal operation; the IS-NULL guard returns NULL +--! defensively. A non-NULL composite with NULL `bytes` is a contract violation +--! — the extractor returns SQL NULL (not ROW(NULL)) on missing `oc`, so raise +--! loudly rather than silently misorder. +--! +--! @param a eql_v3_internal.ore_cllw First term +--! @param b eql_v3_internal.ore_cllw Second term +--! @return integer -1, 0, or 1; NULL if either composite is NULL +--! @throws Exception if either composite has a NULL `bytes` field +--! @see eql_v3_internal.compare_ore_cllw_term_bytes +CREATE FUNCTION eql_v3_internal.compare_ore_cllw_term(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) +RETURNS int + SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + len_a INT; + len_b INT; + common_len INT; + cmp_result INT; +BEGIN + -- The `::text` cast is load-bearing, not a stylistic choice. For the + -- single-field `ore_cllw` composite, `ROW(NULL)::ore_cllw IS NULL` is TRUE + -- but `(ROW(NULL)::ore_cllw)::text IS NULL` is FALSE. Casting to text first + -- means a NULL-component composite falls THROUGH to the RAISE below (the + -- extractor-invariant violation) instead of silently returning NULL and + -- masking it. A plain `a IS NULL` would reintroduce that masking bug. + IF a::text IS NULL OR b::text IS NULL THEN + RETURN NULL; + END IF; + + IF a.bytes IS NULL OR b.bytes IS NULL THEN + RAISE EXCEPTION 'eql_v3_internal.compare_ore_cllw_term: composite has NULL bytes field — extractor invariant violated. Check that the index expression uses eql_v3_internal.ore_cllw(...) and not a hand-crafted ROW(NULL).'; + END IF; + + len_a := LENGTH(a.bytes); + len_b := LENGTH(b.bytes); + + IF len_a = 0 AND len_b = 0 THEN + RETURN 0; + ELSIF len_a = 0 THEN + RETURN -1; + ELSIF len_b = 0 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + common_len := len_a; + ELSE + common_len := len_b; + END IF; + + cmp_result := eql_v3_internal.compare_ore_cllw_term_bytes( + SUBSTRING(a.bytes FROM 1 FOR common_len), + SUBSTRING(b.bytes FROM 1 FOR common_len) + ); + + IF cmp_result = -1 THEN + RETURN -1; + ELSIF cmp_result = 1 THEN + RETURN 1; + END IF; + + IF len_a < len_b THEN + RETURN -1; + ELSIF len_a > len_b THEN + RETURN 1; + ELSE + RETURN 0; + END IF; +END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/blockers.sql +--! @brief Native-jsonb firewall for public.json. +--! +--! public.json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! = <> < <= > >= are supported on public.jsonb_entry only, not on the root +--! document domain. +--! Every OTHER native jsonb operator reachable via domain fallback against the +--! base type jsonb is BLOCKED here so an encrypted column can never silently +--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS +--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||. +--! +--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let +--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the +--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! helpers. Each blocker's RETURNS type matches the native operator it shadows +--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a +--! composed expression resolves and the body raises 'operator not supported', +--! rather than failing earlier with a misleading 'operator does not exist' on a +--! boolean intermediate. The bound operator must resolve before native fallback, +--! so the firewall fires. + +--! @brief Blocker: ? (key/element exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b text Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.json, b text) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: ?| (any key exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?|'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: ?& (all keys exist). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.json, b text[]) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '?&'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: @? (jsonpath exists). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonpath Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@?'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: @@ (jsonpath predicate). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonpath Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.json, b jsonpath) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, + LEFTARG = public.json, + RIGHTARG = jsonpath +); + +--! @brief Blocker: #> (path extract, native returns jsonb). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '#>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #>> (path extract as text). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return text Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.json, b text[]) +RETURNS text +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.json', '#>>'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: - (delete key, text RHS; native returns jsonb). +--! @param a public.json Left operand (encrypted payload). +--! @param b text Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.json, b text) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, + LEFTARG = public.json, + RIGHTARG = text +); + +--! @brief Blocker: - (delete index, integer RHS). +--! @param a public.json Left operand (encrypted payload). +--! @param b integer Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.json, b integer) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, + LEFTARG = public.json, + RIGHTARG = integer +); + +--! @brief Blocker: - (delete keys, text[] RHS). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: #- (delete at path). +--! @param a public.json Left operand (encrypted payload). +--! @param b text[] Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.json, b text[]) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '#-'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, + LEFTARG = public.json, + RIGHTARG = text[] +); + +--! @brief Blocker: || (concatenate, encrypted on the left). +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.json, b jsonb) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +--! @brief Blocker: || (concatenate, encrypted on the right). +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return jsonb Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.json) +RETURNS jsonb +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.json', '||'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Root-document comparison blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: root public.json document comparisons. +--! @param a public.json Left operand (encrypted payload). +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.json, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root public.json-to-jsonb comparisons. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: root jsonb-to-public.json comparisons. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', 'comparison'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.json, + RIGHTARG = public.json +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +------------------------------------------------------------------------------ +-- Mixed jsonb containment blockers. +------------------------------------------------------------------------------ + +--! @brief Blocker: @> with encrypted root document and native jsonb. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: @> with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '@>'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with encrypted root document and native jsonb. +--! @param a public.json Left operand (encrypted payload). +--! @param b jsonb Native RHS operand. +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.json, b jsonb) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +--! @brief Blocker: <@ with native jsonb and encrypted root document. +--! @param a jsonb Native LHS operand. +--! @param b public.json Right operand (encrypted payload). +--! @return boolean Never returns; always raises 'operator not supported'. +CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.json) +RETURNS boolean +IMMUTABLE PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.json', '<@'); +END; +$$ LANGUAGE plpgsql; + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = public.json, + RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + LEFTARG = jsonb, + RIGHTARG = public.json +); + +--! @file v3/sem/ore_cllw/operators.sql +--! @brief Comparison operators on the eql_v3_internal.ore_cllw composite type. +--! +--! Each backing function reduces to a single SELECT over +--! eql_v3_internal.compare_ore_cllw_term(a, b) and is inlinable so the planner can fold +--! it through to functional-index matching. The inner comparator is plpgsql +--! (per-byte loop) and is not inlined — fine for index *match*. +--! +--! @note Deliberately no HASHES / MERGES — the CLLW protocol gives ordering, +--! not a hash; there is no merge-joinable opclass on the other side. +--! @see eql_v3_internal.compare_ore_cllw_term + +--! @brief Equality backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_eq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 0 +$$; + +--! @brief Not-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the CLLW ORE terms are not equal +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_neq(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 0 +$$; + +--! @brief Less-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_lte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> 1 +$$; + +--! @brief Greater-than backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gt(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for eql_v3_internal.ore_cllw. +--! @internal +--! +--! @param a eql_v3_internal.ore_cllw Left operand +--! @param b eql_v3_internal.ore_cllw Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_cllw_term +CREATE FUNCTION eql_v3_internal.ore_cllw_gte(a eql_v3_internal.ore_cllw, b eql_v3_internal.ore_cllw) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_cllw_term(a, b) <> -1 +$$; + + +CREATE OPERATOR public.= ( + FUNCTION = eql_v3_internal.ore_cllw_eq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +CREATE OPERATOR public.<> ( + FUNCTION = eql_v3_internal.ore_cllw_neq, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +CREATE OPERATOR public.< ( + FUNCTION = eql_v3_internal.ore_cllw_lt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +CREATE OPERATOR public.<= ( + FUNCTION = eql_v3_internal.ore_cllw_lte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +CREATE OPERATOR public.> ( + FUNCTION = eql_v3_internal.ore_cllw_gt, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +CREATE OPERATOR public.>= ( + FUNCTION = eql_v3_internal.ore_cllw_gte, + LEFTARG = eql_v3_internal.ore_cllw, + RIGHTARG = eql_v3_internal.ore_cllw, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/jsonb/functions.sql +--! @brief Extractors, containment engine, and path/array functions for the +--! eql_v3 encrypted-JSONB (SteVec) surface. +--! +--! `selector` parameters here are *encrypted-side* selector hashes — the +--! deterministic hash the crypto layer emits in the `s` field of each sv +--! element. Plaintext JSONPaths are never accepted at runtime. + +------------------------------------------------------------------------------ +-- Envelope helpers (eql_v3 owns these; jsonb-only) +------------------------------------------------------------------------------ + +--! @brief Extract metadata (i, v) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return jsonb Metadata object with `i` and `v` fields. +CREATE FUNCTION eql_v3.meta_data(val jsonb) + RETURNS jsonb + IMMUTABLE STRICT PARALLEL SAFE + LANGUAGE SQL +AS $$ + SELECT jsonb_build_object('i', val->'i', 'v', val->'v'); +$$; + +COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS + 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; + +--! @brief Extract ciphertext (c) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text Base64-encoded ciphertext. +--! @throws Exception if `c` is absent. +CREATE FUNCTION eql_v3.ciphertext(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'c' THEN + RETURN val->>'c'; + END IF; + RAISE 'Expected a ciphertext (c) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Selector extractors +------------------------------------------------------------------------------ + +--! @brief Extract selector (s) from a raw jsonb encrypted value. +--! @param val jsonb encrypted EQL payload +--! @return text The selector value. +--! @throws Exception if `s` is absent. +CREATE FUNCTION eql_v3.selector(val jsonb) + RETURNS text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 's' THEN + RETURN val->>'s'; + END IF; + RAISE 'Expected a selector index (s) value in json: %', val; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK +--! guarantees `s` is present, so this is a simple field access. +--! @param entry public.jsonb_entry +--! @return text The selector value. +CREATE FUNCTION eql_v3.selector(entry public.jsonb_entry) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 's' +$$; + +------------------------------------------------------------------------------ +-- Equality-term extractor (XOR-aware: coalesce(hm, oc)) +------------------------------------------------------------------------------ + +--! @brief XOR-aware equality term extractor for public.jsonb_entry. +--! +--! Returns the bytea of whichever deterministic term the sv entry carries — +--! `hm` (HMAC-256) or `oc` (CLLW ORE). The two byte distributions are disjoint +--! by construction, so byte equality on the coalesce is unambiguous. Canonical +--! equality extractor used by `=` / `<>` on jsonb_entry. +--! +--! @param entry public.jsonb_entry +--! @return bytea Decoded `hm` or `oc` bytes (NULL if entry is NULL). +CREATE FUNCTION eql_v3.eq_term(entry public.jsonb_entry) + RETURNS bytea + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT decode(coalesce(entry ->> 'hm', entry ->> 'oc'), 'hex') +$$; + +------------------------------------------------------------------------------ +-- ORE CLLW per-entry overloads (live here so sem/ore_cllw stays a leaf) +------------------------------------------------------------------------------ + +--! @brief Extract CLLW ORE index term from a ste_vec entry. +--! +--! `oc` is only ever present on an sv element, never at a root encrypted value, +--! so the typed overload accepts public.jsonb_entry. Returns SQL NULL when +--! `oc` is absent (btree NULL-filters such rows from range queries). +--! +--! @param entry public.jsonb_entry +--! @return eql_v3_internal.ore_cllw Composite carrying the CLLW ciphertext, or NULL. +--! @see eql_v3.has_ore_cllw +CREATE FUNCTION eql_v3.ore_cllw(entry public.jsonb_entry) + RETURNS eql_v3_internal.ore_cllw + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE WHEN entry ->> 'oc' IS NULL THEN NULL + ELSE ROW(decode(entry ->> 'oc', 'hex'))::eql_v3_internal.ore_cllw + END +$$; + +--! @brief Check if a ste_vec entry contains a CLLW ORE index term. +--! @param entry public.jsonb_entry +--! @return boolean True if `oc` is present and non-null. +CREATE FUNCTION eql_v3.has_ore_cllw(entry public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT entry ->> 'oc' IS NOT NULL +$$; + +------------------------------------------------------------------------------ +-- sv-array helpers +------------------------------------------------------------------------------ + +--! @brief Extract the sv element array as raw jsonb[]. +--! +--! Returns the elements of `sv` (or a single-element array wrapping the value +--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of sv elements. +CREATE FUNCTION eql_v3.ste_vec(val jsonb) + RETURNS jsonb[] + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb; + ary jsonb[]; + BEGIN + IF val ? 'sv' THEN + sv := val->'sv'; + ELSE + sv := jsonb_build_array(val); + END IF; + + SELECT array_agg(elem) + INTO ary + FROM jsonb_array_elements(sv) AS elem; + + RETURN ary; + END; +$$ LANGUAGE plpgsql; + +--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). +--! @param val jsonb encrypted EQL payload +--! @return boolean True if `a` is present and true. +CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + BEGIN + IF val ? 'a' THEN + RETURN (val->>'a')::boolean; + END IF; + RETURN false; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Deterministic-fields array for GIN containment +------------------------------------------------------------------------------ + +--! @brief Extract deterministic search fields (s, hm, oc, op) per sv element. +--! +--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can +--! compare for containment. Use for GIN indexes and containment queries. +--! +--! @param val jsonb encrypted EQL payload +--! @return jsonb[] Array of objects with only deterministic fields. +CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +RETURNS jsonb[] +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT ARRAY( + SELECT jsonb_object_agg(kv.key, kv.value) + FROM jsonb_array_elements( + CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END + ) AS elem, + LATERAL jsonb_each(elem) AS kv(key, value) + WHERE kv.key IN ('s', 'hm', 'oc', 'op') + GROUP BY elem + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS + 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Containment +------------------------------------------------------------------------------ + +--! @brief GIN-indexable containment check: does `a` contain all of `b`? +--! @param a jsonb Container payload. +--! @param b jsonb Search payload. +--! @return boolean True if a contains all deterministic elements of b. +--! @note Public raw-`jsonb[]` containment helper over the extracted +--! deterministic fields — the function-form entrypoint for containment on +--! platforms without operator support (Supabase/PostgREST). The typed +--! `public.json` `@>` operator does NOT call this function — it binds to +--! `eql_v3.ste_vec_contains` instead — but both agree on the result (a +--! parity test pins this). Also the documented GIN index expression +--! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; + +--! @brief GIN-indexable "is contained by" check. +--! @param a jsonb Payload to check. +--! @param b jsonb Container payload. +--! @return boolean True if all elements of a are contained in b. +--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form +--! entrypoint for `<@` on platforms without operator support. The typed +--! `public.json` `<@` operator binds to `eql_v3.ste_vec_contains` instead, +--! but both agree on the result. +CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +RETURNS boolean +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE SQL +AS $$ + SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS + 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if an sv array contains a specific sv element. +--! +--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm, +--! oc)). This collapses the v2 hm/oc CASE: under the XOR contract both terms +--! are deterministic and byte-disjoint, so either one is a valid equality +--! discriminator and a single byte comparison is correct. +--! +--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and oc byte +--! distributions never collide at a given selector. The crypto layer configures +--! a selector for eq XOR ordered, so both sides of a real comparison carry the +--! same term type; and an oc value carries a leading domain-tag byte an hm never +--! has. Unlike v2's explicit `has_hmac(both)`/`has_ore_cllw(both)`/`ELSE false` +--! CASE, this collapse would wrongly match an hm needle against an oc leaf if +--! their hex bytes were ever identical — which the contract prevents. The +--! negative-containment test guards against regression. +--! +--! @param a jsonb[] sv array to search within. +--! @param b jsonb sv element to search for. +--! @return boolean True if b is found in any element of a. +CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + _a jsonb; + BEGIN + result := false; + + FOR idx IN 1..array_length(a, 1) LOOP + _a := a[idx]; + result := result OR ( + eql_v3.selector(_a) = eql_v3.selector(b) + AND eql_v3.eq_term(_a::public.jsonb_entry) = eql_v3.eq_term(b::public.jsonb_entry) + ); + EXIT WHEN result; + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +--! @brief Does encrypted value `a` contain all sv elements of `b`? +--! +--! Empty b is always contained. Each element of b must match selector + eq_term +--! in some element of a. +--! +--! @param a public.json Container. +--! @param b public.json Elements to find. +--! @return boolean True if all elements of b are contained in a. +--! @see eql_v3.ste_vec_contains(jsonb[], jsonb) +CREATE FUNCTION eql_v3.ste_vec_contains(a public.json, b public.json) + RETURNS boolean + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + result boolean; + sv_a jsonb[]; + sv_b jsonb[]; + _b jsonb; + BEGIN + sv_a := eql_v3.ste_vec(a); + sv_b := eql_v3.ste_vec(b); + + IF array_length(sv_b, 1) IS NULL THEN + RETURN true; + END IF; + + IF array_length(sv_a, 1) IS NULL THEN + RETURN false; + END IF; + + result := true; + + FOR idx IN 1..array_length(sv_b, 1) LOOP + _b := sv_b[idx]; + result := result AND eql_v3.ste_vec_contains(sv_a, _b); + END LOOP; + + RETURN result; + END; +$$ LANGUAGE plpgsql; + +------------------------------------------------------------------------------ +-- Path queries (text selector only) +------------------------------------------------------------------------------ + +--! @brief Query encrypted JSONB for sv elements matching `selector`. +--! +--! Returns one jsonb_entry row per matching encrypted element. Returns empty +--! set on no match. It deliberately does not wrap multiple matches as an +--! public.json document, because the root document domain requires an `sv` +--! array and single leaves belong to public.jsonb_entry. +--! +--! @param val jsonb encrypted EQL payload with `sv`. +--! @param selector text Selector hash (`s` value). +--! @return SETOF public.jsonb_entry Matching encrypted entries. +--! @see eql_v3.jsonb_path_query_first +CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; + +--! @brief Check if a selector path exists in encrypted JSONB. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to test. +--! @return boolean True if a matching element exists. +CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT EXISTS ( + SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + ); +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; + +--! @brief Get the first sv element matching `selector`, or NULL. +--! @param val jsonb encrypted EQL payload. +--! @param selector text Selector hash to match. +--! @return public.jsonb_entry First matching element or NULL. +CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT (eql_v3.meta_data(val) || elem)::public.jsonb_entry + FROM jsonb_array_elements(val -> 'sv') elem + WHERE elem ->> 's' = selector + LIMIT 1 +$$; + +COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS + 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; + +------------------------------------------------------------------------------ +-- Array functions +------------------------------------------------------------------------------ + +--! @brief Get the length of an encrypted JSONB array. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return integer Number of elements. +--! @throws Exception 'cannot get array length of a non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) + RETURNS integer + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF eql_v3_internal.is_ste_vec_array(val) THEN + sv := eql_v3.ste_vec(val); + RETURN array_length(sv, 1); + END IF; + + RAISE 'cannot get array length of a non-array'; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract elements of an encrypted JSONB array as rows. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF public.jsonb_entry One row per element (metadata preserved). +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) + RETURNS SETOF public.jsonb_entry + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + meta jsonb; + item jsonb; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; + + meta := eql_v3.meta_data(val); + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + item = sv[idx]; + RETURN NEXT (meta || item)::public.jsonb_entry; + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @brief Extract elements of an encrypted JSONB array as ciphertext text. +--! @param val jsonb encrypted EQL payload (must have `a` flag true). +--! @return SETOF text One ciphertext per element. +--! @throws Exception 'cannot extract elements from non-array' if not an array. +CREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb) + RETURNS SETOF text + IMMUTABLE STRICT PARALLEL SAFE + SET search_path = pg_catalog, extensions, public +AS $$ + DECLARE + sv jsonb[]; + BEGIN + IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + RAISE 'cannot extract elements from non-array'; + END IF; + + sv := eql_v3.ste_vec(val); + + FOR idx IN 1..array_length(sv, 1) LOOP + RETURN NEXT eql_v3.ciphertext(sv[idx]); + END LOOP; + + RETURN; + END; +$$ LANGUAGE plpgsql; + +--! @file v3/jsonb/aggregates.sql +--! @brief min / max aggregates over public.jsonb_entry. +--! +--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by +--! their CLLW ORE (`oc`) term, so the extremum is picked by comparing +--! `eql_v3.ore_cllw(entry)` rather than the scalar Block-ORE `ord_term` the +--! generated scalar ord aggregates use. Same STRICT + PARALLEL SAFE shape as the +--! generated scalar `min`/`max` so partial/parallel aggregation is available on +--! large GROUP BY workloads. +--! +--! Per the encrypted-domain footgun rules the state functions are +--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would +--! be inlinable and the planner could elide it. +--! +--! @note **Only `oc`-carrying entries are orderable.** `eql_v3.ore_cllw(entry)` +--! returns NULL when an entry has no `oc` (CLLW ORE) term — the same entries a +--! `eql_v3.ore_cllw` btree NULL-filters from range scans. The state functions +--! therefore IGNORE `oc`-less entries (they never become or survive as the +--! extremum), so `min`/`max` is well-defined over a mix of `oc`-carrying and +--! `oc`-less entries and is not corrupted by an `oc`-less seed. A naive +--! `ore_cllw(value) < ore_cllw(state)` would be NULL whenever either side +--! lacks `oc`, pinning a wrong (`oc`-less) extremum when the first aggregated +--! row is `oc`-less. An all-`oc`-less input has no orderable extremum and +--! returns the (arbitrary) STRICT seed. + +--! @brief State function for min on public.jsonb_entry. +--! +--! Keeps whichever orderable entry has the lesser CLLW ORE term. STRICT, so SQL +--! NULL entries are skipped by the aggregate machinery; `oc`-less (non-orderable) +--! entries are skipped explicitly (see the @note on this file). +--! +--! @param state public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The lesser orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly greater. + IF state_ore IS NULL OR value_ore < state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate over public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the smallest CLLW ORE term. +CREATE AGGREGATE eql_v3.min(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_min_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.jsonb_entry. +--! +--! Keeps whichever orderable entry has the greater CLLW ORE term. `oc`-less +--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). +--! +--! @param state public.jsonb_entry Running extremum. +--! @param value public.jsonb_entry Candidate entry. +--! @return public.jsonb_entry The greater orderable entry by `ore_cllw`. +CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( + state public.jsonb_entry, + value public.jsonb_entry +) +RETURNS public.jsonb_entry +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +DECLARE + value_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(value); + state_ore eql_v3_internal.ore_cllw := eql_v3.ore_cllw(state); +BEGIN + -- A non-orderable (oc-less) candidate never replaces the running extremum. + IF value_ore IS NULL THEN + RETURN state; + END IF; + -- Adopt the candidate when the running extremum is itself non-orderable + -- (e.g. an oc-less STRICT seed) or strictly lesser. + IF state_ore IS NULL OR value_ore > state_ore THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate over public.jsonb_entry. +--! @param input public.jsonb_entry +--! @return public.jsonb_entry The entry with the largest CLLW ORE term. +CREATE AGGREGATE eql_v3.max(public.jsonb_entry) ( + sfunc = eql_v3_internal.jsonb_entry_max_sfunc, + stype = public.jsonb_entry, + combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, + parallel = safe +); + +--! @file v3/sem/ore_cllw/operator_class.sql +--! @brief Btree operator class on the eql_v3_internal.ore_cllw composite type. +--! +--! DEFAULT FOR TYPE so a functional btree index on eql_v3_internal.ore_cllw(expr) +--! engages without an explicit opclass annotation. FUNCTION 1 is the three-way +--! comparator btree's internal sort uses; it is plpgsql by design (per-byte +--! CLLW protocol needs iteration) and is called once per index-entry pair +--! during build / search, not per-row in the outer query. +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_cllw are unavailable, but +--! the order-preserving (OPE) ordering domains — whose extractor return +--! types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_cllw_term + +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_cllw_ops USING btree'; + + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_cllw_ops + DEFAULT FOR TYPE eql_v3_internal.ore_cllw + USING btree FAMILY eql_v3_internal.ore_cllw_ops AS + OPERATOR 1 public.< (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 2 public.<= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 3 public.= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 4 public.>= (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + OPERATOR 5 public.> (eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw), + FUNCTION 1 eql_v3_internal.compare_ore_cllw_term(eql_v3_internal.ore_cllw, eql_v3_internal.ore_cllw) + $ddl$; + + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_cllw_ops'; +EXCEPTION + WHEN insufficient_privilege THEN + RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_cllw_ops (requires superuser); ORE ordered indexes on ore_cllw unavailable, OPE ordering domains unaffected'; +END; +$do$; + +--! @file v3/sem/ore_block_256/operators.sql +--! @brief Comparison operators on eql_v3_internal.ore_block_256. +--! +--! The six backing functions are inlinable single-statement SQL so the planner +--! can fold the eql_v3 comparison wrappers through to functional-index matching. + +--! @brief Equality backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 +$$; + +--! @brief Not-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the ORE blocks are not equal +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 +$$; + +--! @brief Less-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 +$$; + +--! @brief Less-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is less than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 +$$; + +--! @brief Greater-than backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 +$$; + +--! @brief Greater-than-or-equal backing function for ORE block types +--! @internal +--! +--! @param a eql_v3_internal.ore_block_256 Left operand +--! @param b eql_v3_internal.ore_block_256 Right operand +--! @return boolean True if the left operand is greater than or equal to the right operand +--! +--! @see eql_v3_internal.compare_ore_block_256_terms +CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +RETURNS boolean + LANGUAGE sql + IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 +$$; + + +--! @brief = operator for ORE block types +--! +--! COMMUTATOR is the operator itself: equality is symmetric. Required for the +--! MERGES flag — without it the planner raises "could not find commutator" the +--! first time an ore_block equality is used as a join qual (e.g. via the inlined +--! eql_v3_internal._ord_ore equality wrappers). +CREATE OPERATOR public.= ( + FUNCTION=eql_v3_internal.ore_block_256_eq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.=), + NEGATOR = OPERATOR(public.<>), + RESTRICT = eqsel, + JOIN = eqjoinsel, + HASHES, + MERGES +); + +--! @brief <> operator for ORE block types +CREATE OPERATOR public.<> ( + FUNCTION=eql_v3_internal.ore_block_256_neq, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<>), + NEGATOR = OPERATOR(public.=), + RESTRICT = neqsel, + JOIN = neqjoinsel, + MERGES +); + +--! @brief > operator for ORE block types +CREATE OPERATOR public.> ( + FUNCTION=eql_v3_internal.ore_block_256_gt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<), + NEGATOR = OPERATOR(public.<=), + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief < operator for ORE block types +CREATE OPERATOR public.< ( + FUNCTION=eql_v3_internal.ore_block_256_lt, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>), + NEGATOR = OPERATOR(public.>=), + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief <= operator for ORE block types +CREATE OPERATOR public.<= ( + FUNCTION=eql_v3_internal.ore_block_256_lte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.>=), + NEGATOR = OPERATOR(public.>), + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief >= operator for ORE block types +CREATE OPERATOR public.>= ( + FUNCTION=eql_v3_internal.ore_block_256_gte, + LEFTARG=eql_v3_internal.ore_block_256, + RIGHTARG=eql_v3_internal.ore_block_256, + COMMUTATOR = OPERATOR(public.<=), + NEGATOR = OPERATOR(public.<), + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); + +--! @file v3/sem/ore_block_256/operator_class.sql +--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. +--! +--! Gives the composite type its DEFAULT btree opclass so the recommended +--! functional index `CREATE INDEX ON t (eql_v3_internal.ord_term(col))` engages without +--! an explicit opclass annotation (design D4). +--! +--! @note Creating an operator family/class requires superuser: Postgres forbids +--! CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index +--! integrity. Managed platforms (Supabase, and most hosted Postgres) run +--! the installer as a non-superuser role, so the DO block below ATTEMPTS +--! the creation and skips it on insufficient_privilege (SQLSTATE 42501), +--! letting the single installer run everywhere. When the class is absent, +--! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! but the order-preserving (OPE) ordering domains — whose extractor +--! return types carry a native btree opclass — still index without it. On +--! superuser installs (self-managed Postgres, the SQLx test matrix) the +--! class is created normally. Any non-privilege error still propagates. +--! @see eql_v3_internal.compare_ore_block_256_terms + +DO $do$ +BEGIN + EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; + + EXECUTE $ddl$ + CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class + DEFAULT FOR TYPE eql_v3_internal.ore_block_256 + USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + OPERATOR 1 public.<, + OPERATOR 2 public.<=, + OPERATOR 3 public.=, + OPERATOR 4 public.>=, + OPERATOR 5 public.>, + FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + $ddl$; + + RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; +EXCEPTION + WHEN insufficient_privilege THEN + RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected'; +END; +$do$; + +--! @file v3/jsonb/operators.sql +--! @brief Operators on public.json and public.jsonb_entry. + +------------------------------------------------------------------------------ +-- -> field accessor (returns jsonb_entry) +------------------------------------------------------------------------------ + +--! @brief -> operator with text selector. +--! +--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged +--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to +--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional +--! index on `eql_v3.eq_term(col -> 'sel')`. +--! +--! @warning The selector operand MUST carry a known type — a text-typed +--! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::text`). +--! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> text` +--! operator and silently returns native jsonb semantics (a root-key lookup, +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.json` +--! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the +--! native base-type operator wins the exact-match tiebreak. This is intrinsic to +--! the domain type-kind and applies to the native-jsonb blockers too. See +--! the "Typed operands" caveat in docs/reference/json-support.md. +--! +--! @param e public.json Root encrypted payload. +--! @param selector text Selector hash. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector text) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT ( + eql_v3.meta_data(e) || + jsonb_path_query_first( + e, + '$.sv[*] ? (@.s == $sel)'::jsonpath, + jsonb_build_object('sel', selector) + ) + )::public.jsonb_entry +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.json, + RIGHTARG=text +); + +--! @brief -> operator with integer array index (0-based, JSONB convention). +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return public.jsonb_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION eql_v3."->"(e public.json, selector integer) + RETURNS public.jsonb_entry + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT CASE + WHEN eql_v3_internal.is_ste_vec_array(e) THEN + -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.json` to + -- its base type and binds native `jsonb -> text` (see the @warning above) — + -- the custom `->(public.json, text)` operator does NOT capture a bare + -- untyped literal. The cast documents that intent and guards the `-> selector` + -- (integer) hop from ever resolving to the v3 `->(public.json, integer)` + -- operator instead of native array access. + (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.jsonb_entry + ELSE NULL + END +$$; + +CREATE OPERATOR ->( + FUNCTION=eql_v3."->", + LEFTARG=public.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- ->> field accessor (alias of -> coerced to text) +------------------------------------------------------------------------------ + +--! @brief ->> operator with text selector. Inlinable alias of -> coerced to +--! text. +--! +--! Intentional v2 parity: this serializes the entire matched jsonb_entry +--! object as JSON text. It does not decrypt or return scalar plaintext like +--! native `jsonb ->>`. +--! @param e public.json Encrypted payload. +--! @param selector text Field selector hash. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.json, selector text) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=public.json, + RIGHTARG=text +); + +--! @brief ->> operator with integer array index. Inlinable alias of +--! ->(json, integer) coerced to text. +--! @param e public.json Encrypted sv-array payload. +--! @param selector integer Array index. +--! @return text The matching entry as text. +CREATE FUNCTION eql_v3."->>"(e public.json, selector integer) + RETURNS text + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."->"(e, selector)::jsonb::text +$$; + +CREATE OPERATOR ->> ( + FUNCTION=eql_v3."->>", + LEFTARG=public.json, + RIGHTARG=integer +); + +------------------------------------------------------------------------------ +-- @> containment +------------------------------------------------------------------------------ + +--! @brief @> contains operator (document, document). +--! @param a public.json Container. +--! @param b public.json Contained value. +--! @return boolean True if a contains b. +--! @see eql_v3.ste_vec_contains +CREATE FUNCTION eql_v3."@>"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(a, b) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.json +); + +--! @brief @> contains operator with an jsonb_query needle. +--! +--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a +--! functional GIN index on the same expression engages. +--! +--! @param a public.json Container. +--! @param b public.jsonb_query Query payload. +--! @return boolean True if a contains b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.jsonb_query) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.jsonb_query +); + +--! @brief @> contains operator with a single jsonb_entry needle. +--! +--! Wraps the entry into a single-element sv array (stripping `c`) and reduces +--! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form. +--! +--! @param a public.json Container. +--! @param b public.jsonb_entry Single entry. +--! @return boolean True if a contains an sv entry matching b. +CREATE FUNCTION eql_v3."@>"(a public.json, b public.jsonb_entry) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.to_ste_vec_query(a)::jsonb + @> jsonb_build_object( + 'sv', + jsonb_build_array( + jsonb_strip_nulls( + jsonb_build_object( + 's', b -> 's', + 'hm', b -> 'hm', + 'oc', b -> 'oc' + ) + ) + ) + ) +$$; + +CREATE OPERATOR @>( + FUNCTION=eql_v3."@>", + LEFTARG=public.json, + RIGHTARG=public.jsonb_entry +); + +------------------------------------------------------------------------------ +-- <@ contained-by (reverse of @>) +------------------------------------------------------------------------------ + +--! @brief <@ contained-by operator (document, document). +--! @param a public.json Contained value. +--! @param b public.json Container. +--! @return boolean True if a is contained by b. +CREATE FUNCTION eql_v3."<@"(a public.json, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ste_vec_contains(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.json, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with an jsonb_query LHS. +--! @param a public.jsonb_query Query payload. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_query, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_query, + RIGHTARG=public.json +); + +--! @brief <@ contained-by operator with a jsonb_entry LHS. +--! @param a public.jsonb_entry Single entry. +--! @param b public.json Container. +--! @return boolean True if b contains a. +CREATE FUNCTION eql_v3."<@"(a public.jsonb_entry, b public.json) +RETURNS boolean +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3."@>"(b, a) +$$; + +CREATE OPERATOR <@( + FUNCTION=eql_v3."<@", + LEFTARG=public.jsonb_entry, + RIGHTARG=public.json +); + +------------------------------------------------------------------------------ +-- jsonb_entry comparisons +------------------------------------------------------------------------------ + +--! @brief Equality on jsonb_entry via eq_term (hm-or-oc byte equality). +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are equal +CREATE FUNCTION eql_v3.eq(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) +$$; + +-- Intentionally no HASHES / MERGES here. PostgreSQL requires a hash-joinable +-- operator to appear in a compatible hash opfamily, and a merge-joinable +-- operator to appear as equality in a compatible btree opfamily. jsonb_entry +-- equality is based on eql_v3.eq_term(entry), not raw jsonb/domain equality, so +-- adding only the flags would be unsound. Join/group/dedup on +-- eql_v3.eq_term(doc -> ''::text) unless a jsonb_entry opfamily with +-- eq_term-compatible hash/sort semantics is added. +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = =, + NEGATOR = <>, + RESTRICT = eqsel, + JOIN = eqjoinsel +); + +--! @brief Inequality on jsonb_entry via eq_term. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if the entries are not equal +CREATE FUNCTION eql_v3.neq(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) +$$; + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <>, + NEGATOR = =, + RESTRICT = neqsel, + JOIN = neqjoinsel +); + +--! @brief Less-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than b +CREATE FUNCTION eql_v3.lt(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) < eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >, + NEGATOR = >=, + RESTRICT = scalarltsel, + JOIN = scalarltjoinsel +); + +--! @brief Less-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is less than or equal to b +CREATE FUNCTION eql_v3.lte(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) <= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = >=, + NEGATOR = >, + RESTRICT = scalarlesel, + JOIN = scalarlejoinsel +); + +--! @brief Greater-than on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than b +CREATE FUNCTION eql_v3.gt(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) > eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <, + NEGATOR = <=, + RESTRICT = scalargtsel, + JOIN = scalargtjoinsel +); + +--! @brief Greater-than-or-equal on jsonb_entry via ore_cllw. +--! @param a public.jsonb_entry Left operand +--! @param b public.jsonb_entry Right operand +--! @return boolean True if a is greater than or equal to b +CREATE FUNCTION eql_v3.gte(a public.jsonb_entry, b public.jsonb_entry) + RETURNS boolean + LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ + SELECT eql_v3.ore_cllw(a) >= eql_v3.ore_cllw(b) +$$; + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.jsonb_entry, + RIGHTARG = public.jsonb_entry, + COMMUTATOR = <=, + NEGATOR = <, + RESTRICT = scalargesel, + JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_query_types.sql +--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.bigint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.bigint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq_query IS 'EQL bigint query operand (equality)'; + + --! @brief Query-operand domain public.bigint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_query IS 'EQL bigint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.bigint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope_query IS 'EQL bigint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/bigint/bigint_types.sql +--! @brief Encrypted-domain types for bigint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.bigint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint IS 'EQL encrypted bigint (storage only)'; + + --! @brief Encrypted domain public.bigint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_eq IS 'EQL encrypted bigint (equality)'; + + --! @brief Encrypted domain public.bigint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + + --! @brief Encrypted domain public.bigint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'bigint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.bigint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_functions.sql +--! @brief Functions for public.bigint_eq. + +--! @brief Index extractor for public.bigint_eq. +--! @param a public.bigint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.bigint_eq) $$; + +--! @brief Operator wrapper for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.bigint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector text) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_eq, selector integer) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return public.bigint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_eq) +RETURNS public.bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param selector public.bigint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a public.bigint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_eq. +--! @param a jsonb +--! @param b public.bigint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_operators.sql +--! @brief Operators for public.bigint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_functions.sql +--! @brief Functions for public.bigint_eq_query. + +--! @brief Index extractor for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq +--! @param b public.bigint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.bigint_eq_query. +--! @param a public.bigint_eq_query +--! @param b public.bigint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_eq_query, b public.bigint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_eq_query_operators.sql +--! @brief Operators for public.bigint_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_functions.sql +--! @brief Functions for public.bigint. + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector text) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a public.bigint, selector integer) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return public.bigint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint) +RETURNS public.bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param selector public.bigint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a public.bigint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint. +--! @param a jsonb +--! @param b public.bigint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_operators.sql +--! @brief Operators for public.bigint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = public.bigint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_functions.sql +--! @brief Functions for public.bigint_ord. + +--! @brief Index extractor for public.bigint_ord. +--! @param a public.bigint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.bigint_ord) $$; + +--! @brief Operator wrapper for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector text) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord, selector integer) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord) +RETURNS public.bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param selector public.bigint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a public.bigint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord. +--! @param a jsonb +--! @param b public.bigint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql +--! @brief Functions for public.bigint_ord_ope. + +--! @brief Index extractor for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.bigint_ord_ope) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.bigint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector text) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ope, selector integer) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ope) +RETURNS public.bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param selector public.bigint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a public.bigint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ope. +--! @param a jsonb +--! @param b public.bigint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql +--! @brief Operators for public.bigint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ope. + +--! @brief State function for min on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ope. +--! @param state public.bigint_ord_ope +--! @param value public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ope, value public.bigint_ord_ope) +RETURNS public.bigint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ope. +--! @param input public.bigint_ord_ope +--! @return public.bigint_ord_ope +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_functions.sql +--! @brief Functions for public.bigint_ord_ope_query. + +--! @brief Index extractor for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope +--! @param b public.bigint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ope_query. +--! @param a public.bigint_ord_ope_query +--! @param b public.bigint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope_query, b public.bigint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ope_query_operators.sql +--! @brief Operators for public.bigint_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_operators.sql +--! @brief Operators for public.bigint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql +--! @brief Aggregates for public.bigint_ord. + +--! @brief State function for min on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.min(public.bigint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord. +--! @param state public.bigint_ord +--! @param value public.bigint_ord +--! @return public.bigint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord, value public.bigint_ord) +RETURNS public.bigint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord. +--! @param input public.bigint_ord +--! @return public.bigint_ord +CREATE AGGREGATE eql_v3.max(public.bigint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql +--! @brief Functions for public.bigint_ord_ore. + +--! @brief Index extractor for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.bigint_ord_ore) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.bigint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.bigint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.bigint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector text) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.bigint_ord_ore, selector integer) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.bigint_ord_ore) +RETURNS public.bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.bigint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param selector public.bigint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.bigint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.bigint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.bigint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.bigint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.bigint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.bigint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a public.bigint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.bigint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.bigint_ord_ore. +--! @param a jsonb +--! @param b public.bigint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.bigint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.bigint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql +--! @brief Operators for public.bigint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.bigint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.bigint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.bigint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql +--! @brief Aggregates for public.bigint_ord_ore. + +--! @brief State function for min on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.min(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.bigint_ord_ore. +--! @param state public.bigint_ord_ore +--! @param value public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.bigint_ord_ore, value public.bigint_ord_ore) +RETURNS public.bigint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.bigint_ord_ore. +--! @param input public.bigint_ord_ore +--! @return public.bigint_ord_ore +CREATE AGGREGATE eql_v3.max(public.bigint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.bigint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_functions.sql +--! @brief Functions for public.bigint_ord_ore_query. + +--! @brief Index extractor for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore +--! @param b public.bigint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_ore_query. +--! @param a public.bigint_ord_ore_query +--! @param b public.bigint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore_query, b public.bigint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_ore_query_operators.sql +--! @brief Operators for public.bigint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_functions.sql +--! @brief Functions for public.bigint_ord_query. + +--! @brief Index extractor for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord +--! @param b public.bigint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.bigint_ord_query. +--! @param a public.bigint_ord_query +--! @param b public.bigint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.bigint_ord_query, b public.bigint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/bigint/bigint_ord_query_operators.sql +--! @brief Operators for public.bigint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/boolean/boolean_types.sql +--! @brief Encrypted-domain types for boolean. + +DO $$ +BEGIN + --! @brief Encrypted domain public.boolean. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'boolean' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.boolean AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.boolean IS 'EQL encrypted boolean (storage only)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_functions.sql +--! @brief Functions for public.boolean. + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.boolean, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.boolean) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector text) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a public.boolean, selector integer) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return public.boolean +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.boolean) +RETURNS public.boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.boolean, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param selector public.boolean +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.boolean) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.boolean, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.boolean, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.boolean, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.boolean, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.boolean, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a public.boolean +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.boolean, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.boolean. +--! @param a jsonb +--! @param b public.boolean +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.boolean) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.boolean'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/boolean/boolean_operators.sql +--! @brief Operators for public.boolean. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.boolean +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.boolean, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.boolean, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = public.boolean +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.boolean, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.boolean +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_query_types.sql +--! @brief Query-operand domains for date (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.date_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.date_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_eq_query IS 'EQL date query operand (equality)'; + + --! @brief Query-operand domain public.date_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ore_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_query IS 'EQL date query operand (equality, ordering)'; + + --! @brief Query-operand domain public.date_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ope_query IS 'EQL date query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/date/date_types.sql +--! @brief Encrypted-domain types for date. + +DO $$ +BEGIN + --! @brief Encrypted domain public.date. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date IS 'EQL encrypted date (storage only)'; + + --! @brief Encrypted domain public.date_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_eq IS 'EQL encrypted date (equality)'; + + --! @brief Encrypted domain public.date_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord IS 'EQL encrypted date (equality, ordering)'; + + --! @brief Encrypted domain public.date_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'date_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.date_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.date_ord_ope IS 'EQL encrypted date (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_functions.sql +--! @brief Functions for public.date_eq. + +--! @brief Index extractor for public.date_eq. +--! @param a public.date_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.date_eq) $$; + +--! @brief Operator wrapper for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.date_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector text) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a public.date_eq, selector integer) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return public.date_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_eq) +RETURNS public.date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param selector public.date_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a public.date_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_eq. +--! @param a jsonb +--! @param b public.date_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_operators.sql +--! @brief Operators for public.date_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = public.date_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_functions.sql +--! @brief Functions for public.date_eq_query. + +--! @brief Index extractor for public.date_eq_query. +--! @param a public.date_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.date_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq +--! @param b public.date_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.date_eq_query. +--! @param a public.date_eq_query +--! @param b public.date_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_eq_query, b public.date_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_eq_query_operators.sql +--! @brief Operators for public.date_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_functions.sql +--! @brief Functions for public.date. + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector text) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a public.date, selector integer) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return public.date +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date) +RETURNS public.date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param selector public.date +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a public.date +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date. +--! @param a jsonb +--! @param b public.date +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_operators.sql +--! @brief Operators for public.date. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = public.date +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_functions.sql +--! @brief Functions for public.date_ord. + +--! @brief Index extractor for public.date_ord. +--! @param a public.date_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord) $$; + +--! @brief Operator wrapper for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector text) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord, selector integer) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord) +RETURNS public.date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param selector public.date_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a public.date_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord. +--! @param a jsonb +--! @param b public.date_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_functions.sql +--! @brief Functions for public.date_ord_ope. + +--! @brief Index extractor for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.date_ord_ope) $$; + +--! @brief Operator wrapper for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.date_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector text) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ope, selector integer) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ope) +RETURNS public.date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param selector public.date_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a public.date_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ope. +--! @param a jsonb +--! @param b public.date_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_operators.sql +--! @brief Operators for public.date_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_aggregates.sql +--! @brief Aggregates for public.date_ord_ope. + +--! @brief State function for min on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.min(public.date_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord_ope. +--! @param state public.date_ord_ope +--! @param value public.date_ord_ope +--! @return public.date_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ope, value public.date_ord_ope) +RETURNS public.date_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord_ope. +--! @param input public.date_ord_ope +--! @return public.date_ord_ope +CREATE AGGREGATE eql_v3.max(public.date_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_query_functions.sql +--! @brief Functions for public.date_ord_ope_query. + +--! @brief Index extractor for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope +--! @param b public.date_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ope_query. +--! @param a public.date_ord_ope_query +--! @param b public.date_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ope_query, b public.date_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ope_query_operators.sql +--! @brief Operators for public.date_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_operators.sql +--! @brief Operators for public.date_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = public.date_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_aggregates.sql +--! @brief Aggregates for public.date_ord. + +--! @brief State function for min on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.min(public.date_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord. +--! @param state public.date_ord +--! @param value public.date_ord +--! @return public.date_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord, value public.date_ord) +RETURNS public.date_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord. +--! @param input public.date_ord +--! @return public.date_ord +CREATE AGGREGATE eql_v3.max(public.date_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_functions.sql +--! @brief Functions for public.date_ord_ore. + +--! @brief Index extractor for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.date_ord_ore) $$; + +--! @brief Operator wrapper for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.date_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.date_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.date_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector text +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector text) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector integer +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.date_ord_ore, selector integer) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param selector public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.date_ord_ore) +RETURNS public.date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.date_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param selector public.date_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.date_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.date_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.date_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.date_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.date_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.date_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b public.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a public.date_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.date_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.date_ord_ore. +--! @param a jsonb +--! @param b public.date_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.date_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.date_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_operators.sql +--! @brief Operators for public.date_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.date_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.date_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.date_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_aggregates.sql +--! @brief Aggregates for public.date_ord_ore. + +--! @brief State function for min on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.min(public.date_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.date_ord_ore. +--! @param state public.date_ord_ore +--! @param value public.date_ord_ore +--! @return public.date_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.date_ord_ore, value public.date_ord_ore) +RETURNS public.date_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.date_ord_ore. +--! @param input public.date_ord_ore +--! @return public.date_ord_ore +CREATE AGGREGATE eql_v3.max(public.date_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.date_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_query_functions.sql +--! @brief Functions for public.date_ord_ore_query. + +--! @brief Index extractor for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore +--! @param b public.date_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_ore_query. +--! @param a public.date_ord_ore_query +--! @param b public.date_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_ore_query, b public.date_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_ore_query_operators.sql +--! @brief Operators for public.date_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_query_functions.sql +--! @brief Functions for public.date_ord_query. + +--! @brief Index extractor for public.date_ord_query. +--! @param a public.date_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.date_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord +--! @param b public.date_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.date_ord_query. +--! @param a public.date_ord_query +--! @param b public.date_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.date_ord_query, b public.date_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/date/date_ord_query_operators.sql +--! @brief Operators for public.date_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_query_types.sql +--! @brief Query-operand domains for double (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.double_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.double_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_eq_query IS 'EQL double query operand (equality)'; + + --! @brief Query-operand domain public.double_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ore_query IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain public.double_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_query IS 'EQL double query operand (equality, ordering)'; + + --! @brief Query-operand domain public.double_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ope_query IS 'EQL double query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/double/double_types.sql +--! @brief Encrypted-domain types for double. + +DO $$ +BEGIN + --! @brief Encrypted domain public.double. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double IS 'EQL encrypted double (storage only)'; + + --! @brief Encrypted domain public.double_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_eq IS 'EQL encrypted double (equality)'; + + --! @brief Encrypted domain public.double_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.double_ord IS 'EQL encrypted double (equality, ordering)'; + + --! @brief Encrypted domain public.double_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'double_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.double_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.double_ord_ope IS 'EQL encrypted double (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_functions.sql +--! @brief Functions for public.double_eq. + +--! @brief Index extractor for public.double_eq. +--! @param a public.double_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.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 public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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.double_eq) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.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 public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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.double_eq) $$; + +--! @brief Operator wrapper for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.double_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector text +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector text) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector integer +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a public.double_eq, selector integer) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param selector public.double_eq +--! @return public.double_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_eq) +RETURNS public.double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param selector public.double_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b public.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b public.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a public.double_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_eq. +--! @param a jsonb +--! @param b public.double_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_operators.sql +--! @brief Operators for public.double_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = public.double_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_functions.sql +--! @brief Functions for public.double_eq_query. + +--! @brief Index extractor for public.double_eq_query. +--! @param a public.double_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.double_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.double_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_eq_query, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq +--! @param b public.double_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.double_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.double_eq_query. +--! @param a public.double_eq_query +--! @param b public.double_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_eq_query, b public.double_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_eq_query_operators.sql +--! @brief Operators for public.double_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_functions.sql +--! @brief Functions for public.double. + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector text +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector text) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector integer +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a public.double, selector integer) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param selector public.double +--! @return public.double +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double) +RETURNS public.double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param selector public.double +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b public.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double, b public.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a public.double +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double. +--! @param a jsonb +--! @param b public.double +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_operators.sql +--! @brief Operators for public.double. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = public.double +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_functions.sql +--! @brief Functions for public.double_ord. + +--! @brief Index extractor for public.double_ord. +--! @param a public.double_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord) $$; + +--! @brief Operator wrapper for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector text) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord, selector integer) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord) +RETURNS public.double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param selector public.double_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a public.double_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord. +--! @param a jsonb +--! @param b public.double_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_functions.sql +--! @brief Functions for public.double_ord_ope. + +--! @brief Index extractor for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.double_ord_ope) $$; + +--! @brief Operator wrapper for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.double_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector text +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector text) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector integer +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ope, selector integer) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param selector public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ope) +RETURNS public.double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param selector public.double_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b public.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a public.double_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ope. +--! @param a jsonb +--! @param b public.double_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_operators.sql +--! @brief Operators for public.double_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_aggregates.sql +--! @brief Aggregates for public.double_ord_ope. + +--! @brief State function for min on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.double_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.min(public.double_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord_ope. +--! @param state public.double_ord_ope +--! @param value public.double_ord_ope +--! @return public.double_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ope, value public.double_ord_ope) +RETURNS public.double_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord_ope. +--! @param input public.double_ord_ope +--! @return public.double_ord_ope +CREATE AGGREGATE eql_v3.max(public.double_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_query_functions.sql +--! @brief Functions for public.double_ord_ope_query. + +--! @brief Index extractor for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope +--! @param b public.double_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ope_query. +--! @param a public.double_ord_ope_query +--! @param b public.double_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ope_query, b public.double_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ope_query_operators.sql +--! @brief Operators for public.double_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_operators.sql +--! @brief Operators for public.double_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = public.double_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_aggregates.sql +--! @brief Aggregates for public.double_ord. + +--! @brief State function for min on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.double_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.min(public.double_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord. +--! @param state public.double_ord +--! @param value public.double_ord +--! @return public.double_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord, value public.double_ord) +RETURNS public.double_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord. +--! @param input public.double_ord +--! @return public.double_ord +CREATE AGGREGATE eql_v3.max(public.double_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_functions.sql +--! @brief Functions for public.double_ord_ore. + +--! @brief Index extractor for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.double_ord_ore) $$; + +--! @brief Operator wrapper for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.double_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.double_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.double_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector text +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector text) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector integer +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.double_ord_ore, selector integer) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param selector public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.double_ord_ore) +RETURNS public.double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.double_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param selector public.double_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.double_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.double_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.double_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.double_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.double_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.double_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b public.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a public.double_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.double_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.double_ord_ore. +--! @param a jsonb +--! @param b public.double_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.double_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.double_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_operators.sql +--! @brief Operators for public.double_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.double_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.double_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.double_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_aggregates.sql +--! @brief Aggregates for public.double_ord_ore. + +--! @brief State function for min on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.min(public.double_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.double_ord_ore. +--! @param state public.double_ord_ore +--! @param value public.double_ord_ore +--! @return public.double_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.double_ord_ore, value public.double_ord_ore) +RETURNS public.double_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.double_ord_ore. +--! @param input public.double_ord_ore +--! @return public.double_ord_ore +CREATE AGGREGATE eql_v3.max(public.double_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.double_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_query_functions.sql +--! @brief Functions for public.double_ord_ore_query. + +--! @brief Index extractor for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore +--! @param b public.double_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_ore_query. +--! @param a public.double_ord_ore_query +--! @param b public.double_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_ore_query, b public.double_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_ore_query_operators.sql +--! @brief Operators for public.double_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_query_functions.sql +--! @brief Functions for public.double_ord_query. + +--! @brief Index extractor for public.double_ord_query. +--! @param a public.double_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.double_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord +--! @param b public.double_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.double_ord_query. +--! @param a public.double_ord_query +--! @param b public.double_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.double_ord_query, b public.double_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/double/double_ord_query_operators.sql +--! @brief Operators for public.double_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_query_types.sql +--! @brief Query-operand domains for integer (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.integer_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.integer_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_eq_query IS 'EQL integer query operand (equality)'; + + --! @brief Query-operand domain public.integer_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ore_query IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain public.integer_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_query IS 'EQL integer query operand (equality, ordering)'; + + --! @brief Query-operand domain public.integer_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ope_query IS 'EQL integer query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/integer/integer_types.sql +--! @brief Encrypted-domain types for integer. + +DO $$ +BEGIN + --! @brief Encrypted domain public.integer. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer IS 'EQL encrypted integer (storage only)'; + + --! @brief Encrypted domain public.integer_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_eq IS 'EQL encrypted integer (equality)'; + + --! @brief Encrypted domain public.integer_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.integer_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord IS 'EQL encrypted integer (equality, ordering)'; + + --! @brief Encrypted domain public.integer_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'integer_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.integer_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_functions.sql +--! @brief Functions for public.integer_eq. + +--! @brief Index extractor for public.integer_eq. +--! @param a public.integer_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.integer_eq) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.integer_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.integer_eq) $$; + +--! @brief Operator wrapper for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.integer_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector text +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector text) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector integer +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a public.integer_eq, selector integer) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param selector public.integer_eq +--! @return public.integer_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_eq) +RETURNS public.integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param selector public.integer_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b public.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b public.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a public.integer_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_eq. +--! @param a jsonb +--! @param b public.integer_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_operators.sql +--! @brief Operators for public.integer_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_functions.sql +--! @brief Functions for public.integer_eq_query. + +--! @brief Index extractor for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.integer_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq +--! @param b public.integer_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.integer_eq_query. +--! @param a public.integer_eq_query +--! @param b public.integer_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_eq_query, b public.integer_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_eq_query_operators.sql +--! @brief Operators for public.integer_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_functions.sql +--! @brief Functions for public.integer. + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector text +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector text) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector integer +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a public.integer, selector integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param selector public.integer +--! @return public.integer +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer) +RETURNS public.integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param selector public.integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b public.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b public.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a public.integer +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer. +--! @param a jsonb +--! @param b public.integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_operators.sql +--! @brief Operators for public.integer. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = public.integer +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_functions.sql +--! @brief Functions for public.integer_ord. + +--! @brief Index extractor for public.integer_ord. +--! @param a public.integer_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.integer_ord) $$; + +--! @brief Operator wrapper for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector text) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord, selector integer) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord) +RETURNS public.integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param selector public.integer_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a public.integer_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord. +--! @param a jsonb +--! @param b public.integer_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_functions.sql +--! @brief Functions for public.integer_ord_ope. + +--! @brief Index extractor for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.integer_ord_ope) $$; + +--! @brief Operator wrapper for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.integer_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector text +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector text) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector integer +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ope, selector integer) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param selector public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ope) +RETURNS public.integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param selector public.integer_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b public.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a public.integer_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ope. +--! @param a jsonb +--! @param b public.integer_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_operators.sql +--! @brief Operators for public.integer_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql +--! @brief Aggregates for public.integer_ord_ope. + +--! @brief State function for min on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.min(public.integer_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord_ope. +--! @param state public.integer_ord_ope +--! @param value public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ope, value public.integer_ord_ope) +RETURNS public.integer_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord_ope. +--! @param input public.integer_ord_ope +--! @return public.integer_ord_ope +CREATE AGGREGATE eql_v3.max(public.integer_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_query_functions.sql +--! @brief Functions for public.integer_ord_ope_query. + +--! @brief Index extractor for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope +--! @param b public.integer_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ope_query. +--! @param a public.integer_ord_ope_query +--! @param b public.integer_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope_query, b public.integer_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ope_query_operators.sql +--! @brief Operators for public.integer_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_operators.sql +--! @brief Operators for public.integer_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_aggregates.sql +--! @brief Aggregates for public.integer_ord. + +--! @brief State function for min on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.integer_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.min(public.integer_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord. +--! @param state public.integer_ord +--! @param value public.integer_ord +--! @return public.integer_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord, value public.integer_ord) +RETURNS public.integer_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord. +--! @param input public.integer_ord +--! @return public.integer_ord +CREATE AGGREGATE eql_v3.max(public.integer_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_functions.sql +--! @brief Functions for public.integer_ord_ore. + +--! @brief Index extractor for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.integer_ord_ore) $$; + +--! @brief Operator wrapper for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.integer_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.integer_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.integer_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector text +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector text) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector integer +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.integer_ord_ore, selector integer) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param selector public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.integer_ord_ore) +RETURNS public.integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.integer_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param selector public.integer_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.integer_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.integer_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.integer_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.integer_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.integer_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.integer_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b public.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a public.integer_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.integer_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.integer_ord_ore. +--! @param a jsonb +--! @param b public.integer_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.integer_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.integer_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_operators.sql +--! @brief Operators for public.integer_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.integer_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.integer_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.integer_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql +--! @brief Aggregates for public.integer_ord_ore. + +--! @brief State function for min on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.integer_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.min(public.integer_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.integer_ord_ore. +--! @param state public.integer_ord_ore +--! @param value public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.integer_ord_ore, value public.integer_ord_ore) +RETURNS public.integer_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.integer_ord_ore. +--! @param input public.integer_ord_ore +--! @return public.integer_ord_ore +CREATE AGGREGATE eql_v3.max(public.integer_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.integer_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_query_functions.sql +--! @brief Functions for public.integer_ord_ore_query. + +--! @brief Index extractor for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore +--! @param b public.integer_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_ore_query. +--! @param a public.integer_ord_ore_query +--! @param b public.integer_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore_query, b public.integer_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_ore_query_operators.sql +--! @brief Operators for public.integer_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_query_functions.sql +--! @brief Functions for public.integer_ord_query. + +--! @brief Index extractor for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord +--! @param b public.integer_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.integer_ord_query. +--! @param a public.integer_ord_query +--! @param b public.integer_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.integer_ord_query, b public.integer_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/integer/integer_ord_query_operators.sql +--! @brief Operators for public.integer_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_query_types.sql +--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.numeric_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.numeric_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_eq_query IS 'EQL numeric query operand (equality)'; + + --! @brief Query-operand domain public.numeric_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_ore_query IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain public.numeric_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_query IS 'EQL numeric query operand (equality, ordering)'; + + --! @brief Query-operand domain public.numeric_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric_ord_ope_query IS 'EQL numeric query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/numeric/numeric_types.sql +--! @brief Encrypted-domain types for numeric. + +DO $$ +BEGIN + --! @brief Encrypted domain public.numeric. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.numeric AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.numeric IS 'EQL encrypted numeric (storage only)'; + + --! @brief Encrypted domain public.numeric_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_eq IS 'EQL encrypted numeric (equality)'; + + --! @brief Encrypted domain public.numeric_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + + --! @brief Encrypted domain public.numeric_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'numeric_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.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; + + COMMENT ON DOMAIN public.numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_functions.sql +--! @brief Functions for public.numeric_eq. + +--! @brief Index extractor for public.numeric_eq. +--! @param a public.numeric_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.numeric_eq) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.numeric_eq) $$; + +--! @brief Operator wrapper for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.numeric_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector text +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector text) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector integer +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_eq, selector integer) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param selector public.numeric_eq +--! @return public.numeric_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_eq) +RETURNS public.numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param selector public.numeric_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b public.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b public.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a public.numeric_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_eq. +--! @param a jsonb +--! @param b public.numeric_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_operators.sql +--! @brief Operators for public.numeric_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_query_functions.sql +--! @brief Functions for public.numeric_eq_query. + +--! @brief Index extractor for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq +--! @param b public.numeric_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.numeric_eq_query. +--! @param a public.numeric_eq_query +--! @param b public.numeric_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_eq_query, b public.numeric_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_eq_query_operators.sql +--! @brief Operators for public.numeric_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_functions.sql +--! @brief Functions for public.numeric. + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector text +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector text) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector integer +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a public.numeric, selector integer) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param selector public.numeric +--! @return public.numeric +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric) +RETURNS public.numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param selector public.numeric +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b public.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b public.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a public.numeric +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric. +--! @param a jsonb +--! @param b public.numeric +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_operators.sql +--! @brief Operators for public.numeric. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = public.numeric +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_functions.sql +--! @brief Functions for public.numeric_ord. + +--! @brief Index extractor for public.numeric_ord. +--! @param a public.numeric_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord) $$; + +--! @brief Operator wrapper for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector text +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector text) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector integer +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord, selector integer) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param selector public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord) +RETURNS public.numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param selector public.numeric_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b public.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b public.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a public.numeric_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord. +--! @param a jsonb +--! @param b public.numeric_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql +--! @brief Functions for public.numeric_ord_ope. + +--! @brief Index extractor for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.numeric_ord_ope) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.numeric_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector text +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector text) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector integer +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ope, selector integer) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param selector public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ope) +RETURNS public.numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param selector public.numeric_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b public.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a public.numeric_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ope. +--! @param a jsonb +--! @param b public.numeric_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql +--! @brief Operators for public.numeric_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ope. + +--! @brief State function for min on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord_ope. +--! @param state public.numeric_ord_ope +--! @param value public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ope, value public.numeric_ord_ope) +RETURNS public.numeric_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord_ope. +--! @param input public.numeric_ord_ope +--! @return public.numeric_ord_ope +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_query_functions.sql +--! @brief Functions for public.numeric_ord_ope_query. + +--! @brief Index extractor for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope +--! @param b public.numeric_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ope_query. +--! @param a public.numeric_ord_ope_query +--! @param b public.numeric_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope_query, b public.numeric_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ope_query_operators.sql +--! @brief Operators for public.numeric_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_operators.sql +--! @brief Operators for public.numeric_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql +--! @brief Aggregates for public.numeric_ord. + +--! @brief State function for min on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.min(public.numeric_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord. +--! @param state public.numeric_ord +--! @param value public.numeric_ord +--! @return public.numeric_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord, value public.numeric_ord) +RETURNS public.numeric_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord. +--! @param input public.numeric_ord +--! @return public.numeric_ord +CREATE AGGREGATE eql_v3.max(public.numeric_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql +--! @brief Functions for public.numeric_ord_ore. + +--! @brief Index extractor for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.numeric_ord_ore) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.numeric_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.numeric_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.numeric_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector text +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector text) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector integer +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.numeric_ord_ore, selector integer) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param selector public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.numeric_ord_ore) +RETURNS public.numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.numeric_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param selector public.numeric_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.numeric_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.numeric_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.numeric_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.numeric_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.numeric_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.numeric_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b public.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a public.numeric_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.numeric_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.numeric_ord_ore. +--! @param a jsonb +--! @param b public.numeric_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.numeric_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.numeric_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql +--! @brief Operators for public.numeric_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.numeric_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.numeric_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.numeric_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql +--! @brief Aggregates for public.numeric_ord_ore. + +--! @brief State function for min on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.min(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.numeric_ord_ore. +--! @param state public.numeric_ord_ore +--! @param value public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.numeric_ord_ore, value public.numeric_ord_ore) +RETURNS public.numeric_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.numeric_ord_ore. +--! @param input public.numeric_ord_ore +--! @return public.numeric_ord_ore +CREATE AGGREGATE eql_v3.max(public.numeric_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.numeric_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_functions.sql +--! @brief Functions for public.numeric_ord_ore_query. + +--! @brief Index extractor for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore +--! @param b public.numeric_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_ore_query. +--! @param a public.numeric_ord_ore_query +--! @param b public.numeric_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore_query, b public.numeric_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_ore_query_operators.sql +--! @brief Operators for public.numeric_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_query_functions.sql +--! @brief Functions for public.numeric_ord_query. + +--! @brief Index extractor for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord +--! @param b public.numeric_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.numeric_ord_query. +--! @param a public.numeric_ord_query +--! @param b public.numeric_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.numeric_ord_query, b public.numeric_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/numeric/numeric_ord_query_operators.sql +--! @brief Operators for public.numeric_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_query_types.sql +--! @brief Query-operand domains for real (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.real_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.real_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_eq_query IS 'EQL real query operand (equality)'; + + --! @brief Query-operand domain public.real_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ore_query IS 'EQL real query operand (equality, ordering)'; + + --! @brief Query-operand domain public.real_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_query IS 'EQL real query operand (equality, ordering)'; + + --! @brief Query-operand domain public.real_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ope_query IS 'EQL real query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/real/real_types.sql +--! @brief Encrypted-domain types for real. + +DO $$ +BEGIN + --! @brief Encrypted domain public.real. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real IS 'EQL encrypted real (storage only)'; + + --! @brief Encrypted domain public.real_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_eq IS 'EQL encrypted real (equality)'; + + --! @brief Encrypted domain public.real_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.real_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord IS 'EQL encrypted real (equality, ordering)'; + + --! @brief Encrypted domain public.real_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'real_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.real_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.real_ord_ope IS 'EQL encrypted real (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_functions.sql +--! @brief Functions for public.real_eq. + +--! @brief Index extractor for public.real_eq. +--! @param a public.real_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.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 public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.real_eq) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.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 public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.real_eq) $$; + +--! @brief Operator wrapper for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.real_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector text +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector text) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector integer +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a public.real_eq, selector integer) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param selector public.real_eq +--! @return public.real_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_eq) +RETURNS public.real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param selector public.real_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b public.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b public.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a public.real_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_eq. +--! @param a jsonb +--! @param b public.real_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_operators.sql +--! @brief Operators for public.real_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = public.real_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_query_functions.sql +--! @brief Functions for public.real_eq_query. + +--! @brief Index extractor for public.real_eq_query. +--! @param a public.real_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.real_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.real_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_eq_query, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq +--! @param b public.real_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.real_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.real_eq_query. +--! @param a public.real_eq_query +--! @param b public.real_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_eq_query, b public.real_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_eq_query_operators.sql +--! @brief Operators for public.real_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_functions.sql +--! @brief Functions for public.real. + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector text +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector text) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector integer +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a public.real, selector integer) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param selector public.real +--! @return public.real +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real) +RETURNS public.real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param selector public.real +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b public.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real, b public.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a public.real +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real. +--! @param a jsonb +--! @param b public.real +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_operators.sql +--! @brief Operators for public.real. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = public.real +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_functions.sql +--! @brief Functions for public.real_ord. + +--! @brief Index extractor for public.real_ord. +--! @param a public.real_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord) $$; + +--! @brief Operator wrapper for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector text) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord, selector integer) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord) +RETURNS public.real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param selector public.real_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a public.real_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord. +--! @param a jsonb +--! @param b public.real_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_functions.sql +--! @brief Functions for public.real_ord_ope. + +--! @brief Index extractor for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.real_ord_ope) $$; + +--! @brief Operator wrapper for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.real_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector text) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ope, selector integer) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ope) +RETURNS public.real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param selector public.real_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a public.real_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ope. +--! @param a jsonb +--! @param b public.real_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_operators.sql +--! @brief Operators for public.real_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_aggregates.sql +--! @brief Aggregates for public.real_ord_ope. + +--! @brief State function for min on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.min(public.real_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord_ope. +--! @param state public.real_ord_ope +--! @param value public.real_ord_ope +--! @return public.real_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ope, value public.real_ord_ope) +RETURNS public.real_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord_ope. +--! @param input public.real_ord_ope +--! @return public.real_ord_ope +CREATE AGGREGATE eql_v3.max(public.real_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_query_functions.sql +--! @brief Functions for public.real_ord_ope_query. + +--! @brief Index extractor for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope +--! @param b public.real_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ope_query. +--! @param a public.real_ord_ope_query +--! @param b public.real_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ope_query, b public.real_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ope_query_operators.sql +--! @brief Operators for public.real_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_operators.sql +--! @brief Operators for public.real_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = public.real_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_aggregates.sql +--! @brief Aggregates for public.real_ord. + +--! @brief State function for min on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.min(public.real_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord. +--! @param state public.real_ord +--! @param value public.real_ord +--! @return public.real_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord, value public.real_ord) +RETURNS public.real_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord. +--! @param input public.real_ord +--! @return public.real_ord +CREATE AGGREGATE eql_v3.max(public.real_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_functions.sql +--! @brief Functions for public.real_ord_ore. + +--! @brief Index extractor for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.real_ord_ore) $$; + +--! @brief Operator wrapper for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.real_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.real_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.real_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector text +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector text) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector integer +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.real_ord_ore, selector integer) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param selector public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.real_ord_ore) +RETURNS public.real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.real_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param selector public.real_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.real_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.real_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.real_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.real_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.real_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.real_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b public.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a public.real_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.real_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.real_ord_ore. +--! @param a jsonb +--! @param b public.real_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.real_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.real_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_operators.sql +--! @brief Operators for public.real_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.real_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.real_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.real_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_aggregates.sql +--! @brief Aggregates for public.real_ord_ore. + +--! @brief State function for min on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.min(public.real_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.real_ord_ore. +--! @param state public.real_ord_ore +--! @param value public.real_ord_ore +--! @return public.real_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.real_ord_ore, value public.real_ord_ore) +RETURNS public.real_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.real_ord_ore. +--! @param input public.real_ord_ore +--! @return public.real_ord_ore +CREATE AGGREGATE eql_v3.max(public.real_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.real_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_functions.sql +--! @brief Functions for public.real_ord_ore_query. + +--! @brief Index extractor for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore +--! @param b public.real_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_ore_query. +--! @param a public.real_ord_ore_query +--! @param b public.real_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_ore_query, b public.real_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_ore_query_operators.sql +--! @brief Operators for public.real_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_query_functions.sql +--! @brief Functions for public.real_ord_query. + +--! @brief Index extractor for public.real_ord_query. +--! @param a public.real_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.real_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord +--! @param b public.real_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.real_ord_query. +--! @param a public.real_ord_query +--! @param b public.real_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.real_ord_query, b public.real_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/real/real_ord_query_operators.sql +--! @brief Operators for public.real_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_query_types.sql +--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.smallint_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.smallint_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_eq_query IS 'EQL smallint query operand (equality)'; + + --! @brief Query-operand domain public.smallint_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ore_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_query IS 'EQL smallint query operand (equality, ordering)'; + + --! @brief Query-operand domain public.smallint_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ope_query IS 'EQL smallint query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/smallint/smallint_types.sql +--! @brief Encrypted-domain types for smallint. + +DO $$ +BEGIN + --! @brief Encrypted domain public.smallint. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint IS 'EQL encrypted smallint (storage only)'; + + --! @brief Encrypted domain public.smallint_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_eq IS 'EQL encrypted smallint (equality)'; + + --! @brief Encrypted domain public.smallint_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.smallint_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + + --! @brief Encrypted domain public.smallint_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'smallint_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.smallint_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_functions.sql +--! @brief Functions for public.smallint_eq. + +--! @brief Index extractor for public.smallint_eq. +--! @param a public.smallint_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.smallint_eq) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.smallint_eq) $$; + +--! @brief Operator wrapper for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.smallint_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector text) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_eq, selector integer) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return public.smallint_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_eq) +RETURNS public.smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param selector public.smallint_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a public.smallint_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_eq. +--! @param a jsonb +--! @param b public.smallint_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_operators.sql +--! @brief Operators for public.smallint_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_query_functions.sql +--! @brief Functions for public.smallint_eq_query. + +--! @brief Index extractor for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq +--! @param b public.smallint_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.smallint_eq_query. +--! @param a public.smallint_eq_query +--! @param b public.smallint_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_eq_query, b public.smallint_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_eq_query_operators.sql +--! @brief Operators for public.smallint_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_functions.sql +--! @brief Functions for public.smallint. + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector text +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector text) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector integer +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a public.smallint, selector integer) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param selector public.smallint +--! @return public.smallint +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint) +RETURNS public.smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param selector public.smallint +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b public.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b public.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a public.smallint +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint. +--! @param a jsonb +--! @param b public.smallint +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_operators.sql +--! @brief Operators for public.smallint. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = public.smallint +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_functions.sql +--! @brief Functions for public.smallint_ord. + +--! @brief Index extractor for public.smallint_ord. +--! @param a public.smallint_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.smallint_ord) $$; + +--! @brief Operator wrapper for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector text) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord, selector integer) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord) +RETURNS public.smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param selector public.smallint_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a public.smallint_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord. +--! @param a jsonb +--! @param b public.smallint_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql +--! @brief Functions for public.smallint_ord_ope. + +--! @brief Index extractor for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.smallint_ord_ope) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.smallint_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector text) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ope, selector integer) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ope) +RETURNS public.smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param selector public.smallint_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a public.smallint_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ope. +--! @param a jsonb +--! @param b public.smallint_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql +--! @brief Operators for public.smallint_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ope. + +--! @brief State function for min on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord_ope. +--! @param state public.smallint_ord_ope +--! @param value public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ope, value public.smallint_ord_ope) +RETURNS public.smallint_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord_ope. +--! @param input public.smallint_ord_ope +--! @return public.smallint_ord_ope +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_query_functions.sql +--! @brief Functions for public.smallint_ord_ope_query. + +--! @brief Index extractor for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope +--! @param b public.smallint_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ope_query. +--! @param a public.smallint_ord_ope_query +--! @param b public.smallint_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope_query, b public.smallint_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ope_query_operators.sql +--! @brief Operators for public.smallint_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_operators.sql +--! @brief Operators for public.smallint_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql +--! @brief Aggregates for public.smallint_ord. + +--! @brief State function for min on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.min(public.smallint_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord. +--! @param state public.smallint_ord +--! @param value public.smallint_ord +--! @return public.smallint_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord, value public.smallint_ord) +RETURNS public.smallint_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord. +--! @param input public.smallint_ord +--! @return public.smallint_ord +CREATE AGGREGATE eql_v3.max(public.smallint_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql +--! @brief Functions for public.smallint_ord_ore. + +--! @brief Index extractor for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.smallint_ord_ore) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.smallint_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.smallint_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.smallint_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector text) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.smallint_ord_ore, selector integer) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.smallint_ord_ore) +RETURNS public.smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.smallint_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param selector public.smallint_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.smallint_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.smallint_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.smallint_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.smallint_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.smallint_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.smallint_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a public.smallint_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.smallint_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.smallint_ord_ore. +--! @param a jsonb +--! @param b public.smallint_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.smallint_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.smallint_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql +--! @brief Operators for public.smallint_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.smallint_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.smallint_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.smallint_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql +--! @brief Aggregates for public.smallint_ord_ore. + +--! @brief State function for min on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.min(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.smallint_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.smallint_ord_ore. +--! @param state public.smallint_ord_ore +--! @param value public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.smallint_ord_ore, value public.smallint_ord_ore) +RETURNS public.smallint_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.smallint_ord_ore. +--! @param input public.smallint_ord_ore +--! @return public.smallint_ord_ore +CREATE AGGREGATE eql_v3.max(public.smallint_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.smallint_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_query_functions.sql +--! @brief Functions for public.smallint_ord_ore_query. + +--! @brief Index extractor for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore +--! @param b public.smallint_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_ore_query. +--! @param a public.smallint_ord_ore_query +--! @param b public.smallint_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore_query, b public.smallint_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_ore_query_operators.sql +--! @brief Operators for public.smallint_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_query_functions.sql +--! @brief Functions for public.smallint_ord_query. + +--! @brief Index extractor for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord +--! @param b public.smallint_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.smallint_ord_query. +--! @param a public.smallint_ord_query +--! @param b public.smallint_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.smallint_ord_query, b public.smallint_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/smallint/smallint_ord_query_operators.sql +--! @brief Operators for public.smallint_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_query_types.sql +--! @brief Query-operand domains for text (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.text_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.text_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_eq_query IS 'EQL text query operand (equality)'; + + --! @brief Query-operand domain public.text_match_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_match_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_match_query IS 'EQL text query operand (containment)'; + + --! @brief Query-operand domain public.text_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ore_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ope_query IS 'EQL text query operand (equality, ordering)'; + + --! @brief Query-operand domain public.text_search_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_search_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_search_query IS 'EQL text query operand (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/text/text_types.sql +--! @brief Encrypted-domain types for text. + +DO $$ +BEGIN + --! @brief Encrypted domain public.text. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text IS 'EQL encrypted text (storage only)'; + + --! @brief Encrypted domain public.text_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_eq IS 'EQL encrypted text (equality)'; + + --! @brief Encrypted domain public.text_match. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_match' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_match AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'bf' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_match IS 'EQL encrypted text (containment)'; + + --! @brief Encrypted domain public.text_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + + --! @brief Encrypted domain public.text_search. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'text_search' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.text_search AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE ? 'ob' + AND VALUE ? 'bf' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.text_search IS 'EQL encrypted text (equality, ordering, containment)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_functions.sql +--! @brief Functions for public.text_eq. + +--! @brief Index extractor for public.text_eq. +--! @param a public.text_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_eq) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_eq) $$; + +--! @brief Operator wrapper for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector text +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector text) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector integer +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a public.text_eq, selector integer) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param selector public.text_eq +--! @return public.text_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_eq) +RETURNS public.text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param selector public.text_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b public.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b public.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a public.text_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_eq. +--! @param a jsonb +--! @param b public.text_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_operators.sql +--! @brief Operators for public.text_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = public.text_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_query_functions.sql +--! @brief Functions for public.text_eq_query. + +--! @brief Index extractor for public.text_eq_query. +--! @param a public.text_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq +--! @param b public.text_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_eq_query. +--! @param a public.text_eq_query +--! @param b public.text_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_eq_query, b public.text_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_eq_query_operators.sql +--! @brief Operators for public.text_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_functions.sql +--! @brief Functions for public.text. + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a public.text, selector integer) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return public.text +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text) +RETURNS public.text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param selector public.text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a public.text +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text. +--! @param a jsonb +--! @param b public.text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_functions.sql +--! @brief Functions for public.text_match. + +--! @brief Index extractor for public.text_match. +--! @param a public.text_match +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.text_match, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.text_match) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_match) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_match) $$; + +--! @brief Operator wrapper for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_match) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector text) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a public.text_match, selector integer) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return public.text_match +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_match) +RETURNS public.text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_match, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param selector public.text_match +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_match) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_match, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_match, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_match, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_match, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_match, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a public.text_match +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_match, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_match. +--! @param a jsonb +--! @param b public.text_match +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_match) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_match'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_operators.sql +--! @brief Operators for public.text_match. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_match +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_match, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_match, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = public.text_match +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_match, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_match +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_functions.sql +--! @brief Functions for public.text_match_query. + +--! @brief Index extractor for public.text_match_query. +--! @param a public.text_match_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_match_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match +--! @param b public.text_match_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_match_query. +--! @param a public.text_match_query +--! @param b public.text_match +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_match_query, b public.text_match) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_match_query_operators.sql +--! @brief Operators for public.text_match_query. + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match, RIGHTARG = public.text_match_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_match_query, RIGHTARG = public.text_match, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_operators.sql +--! @brief Operators for public.text. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = public.text +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_functions.sql +--! @brief Functions for public.text_ord. + +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord. +--! @param a public.text_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_ord) $$; + +--! @brief Operator wrapper for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector text +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector text) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector integer +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord, selector integer) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param selector public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord) +RETURNS public.text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param selector public.text_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b public.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b public.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a public.text_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord. +--! @param a jsonb +--! @param b public.text_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_functions.sql +--! @brief Functions for public.text_ord_ope. + +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.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::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.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::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ope) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.text_ord_ope) $$; + +--! @brief Operator wrapper for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.text_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector text +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector text) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector integer +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ope, selector integer) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param selector public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ope) +RETURNS public.text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param selector public.text_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b public.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a public.text_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ope. +--! @param a jsonb +--! @param b public.text_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_operators.sql +--! @brief Operators for public.text_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_aggregates.sql +--! @brief Aggregates for public.text_ord_ope. + +--! @brief State function for min on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.min(public.text_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord_ope. +--! @param state public.text_ord_ope +--! @param value public.text_ord_ope +--! @return public.text_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ope, value public.text_ord_ope) +RETURNS public.text_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord_ope. +--! @param input public.text_ord_ope +--! @return public.text_ord_ope +CREATE AGGREGATE eql_v3.max(public.text_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_functions.sql +--! @brief Functions for public.text_ord_ope_query. + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope +--! @param b public.text_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ope_query. +--! @param a public.text_ord_ope_query +--! @param b public.text_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ope_query, b public.text_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ope_query_operators.sql +--! @brief Operators for public.text_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_operators.sql +--! @brief Operators for public.text_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = public.text_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_aggregates.sql +--! @brief Aggregates for public.text_ord. + +--! @brief State function for min on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.min(public.text_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord. +--! @param state public.text_ord +--! @param value public.text_ord +--! @return public.text_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord, value public.text_ord) +RETURNS public.text_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord. +--! @param input public.text_ord +--! @return public.text_ord +CREATE AGGREGATE eql_v3.max(public.text_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_functions.sql +--! @brief Functions for public.text_ord_ore. + +--! @brief Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_ord_ore) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_ord_ore) $$; + +--! @brief Operator wrapper for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.text_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.text_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector text) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.text_ord_ore, selector integer) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_ord_ore) +RETURNS public.text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param selector public.text_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a public.text_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_ord_ore. +--! @param a jsonb +--! @param b public.text_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_operators.sql +--! @brief Operators for public.text_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_aggregates.sql +--! @brief Aggregates for public.text_ord_ore. + +--! @brief State function for min on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.min(public.text_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_ord_ore. +--! @param state public.text_ord_ore +--! @param value public.text_ord_ore +--! @return public.text_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_ord_ore, value public.text_ord_ore) +RETURNS public.text_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_ord_ore. +--! @param input public.text_ord_ore +--! @return public.text_ord_ore +CREATE AGGREGATE eql_v3.max(public.text_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_query_functions.sql +--! @brief Functions for public.text_ord_ore_query. + +--! @brief Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore +--! @param b public.text_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_ore_query. +--! @param a public.text_ord_ore_query +--! @param b public.text_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_ore_query, b public.text_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_ore_query_operators.sql +--! @brief Operators for public.text_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_query_functions.sql +--! @brief Functions for public.text_ord_query. + +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_ord_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_ord_query. +--! @param a public.text_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord +--! @param b public.text_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_ord_query. +--! @param a public.text_ord_query +--! @param b public.text_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_ord_query, b public.text_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_ord_query_operators.sql +--! @brief Operators for public.text_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_functions.sql +--! @brief Functions for public.text_search. + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search. +--! @param a public.text_search +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.text_search) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.text_search) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.text_search) $$; + +--! @brief Operator wrapper for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a jsonb, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a::public.text_search) <@ eql_v3.match_term(b) $$; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector text) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a public.text_search, selector integer) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.text_search) +RETURNS public.text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.text_search, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param selector public.text_search +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.text_search) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.text_search, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.text_search, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.text_search, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.text_search, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.text_search, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a public.text_search +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.text_search, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.text_search. +--! @param a jsonb +--! @param b public.text_search +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.text_search) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.text_search'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_operators.sql +--! @brief Operators for public.text_search. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = jsonb, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = jsonb, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.text_search +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.text_search +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.text_search, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.text_search, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = public.text_search +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.text_search, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.text_search +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_aggregates.sql +--! @brief Aggregates for public.text_search. + +--! @brief State function for min on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.min(public.text_search) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.text_search, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.text_search. +--! @param state public.text_search +--! @param value public.text_search +--! @return public.text_search +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.text_search, value public.text_search) +RETURNS public.text_search +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.text_search. +--! @param input public.text_search +--! @return public.text_search +CREATE AGGREGATE eql_v3.max(public.text_search) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.text_search, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_query_functions.sql +--! @brief Functions for public.text_search_query. + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.text_search_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.text_search_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Index extractor for public.text_search_query. +--! @param a public.text_search_query +--! @return eql_v3_internal.bloom_filter +CREATE FUNCTION eql_v3.match_term(a public.text_search_query) +RETURNS eql_v3_internal.bloom_filter +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contains(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search +--! @param b public.text_search_query +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; + +--! @brief Operator wrapper for public.text_search_query. +--! @param a public.text_search_query +--! @param b public.text_search +--! @return boolean +CREATE FUNCTION eql_v3.contained_by(a public.text_search_query, b public.text_search) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/text/text_search_query_operators.sql +--! @brief Operators for public.text_search_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3.contains, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search, RIGHTARG = public.text_search_query, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3.contained_by, + LEFTARG = public.text_search_query, RIGHTARG = public.text_search, + COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_query_types.sql +--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). +--! @note Cast a query operand explicitly to its `_query` domain in a predicate +--! (e.g. `WHERE col = $1::public.timestamp_eq_query`). A bare, +--! uncast literal RHS is ambiguous between the `_query` and `jsonb` +--! operator overloads and will not resolve. + +DO $$ +BEGIN + --! @brief Query-operand domain public.timestamp_eq_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'hm' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq_query IS 'EQL timestamp query operand (equality)'; + + --! @brief Query-operand domain public.timestamp_ord_ore_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'ob' + AND NOT (VALUE ? 'c') + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_query IS 'EQL timestamp query operand (equality, ordering)'; + + --! @brief Query-operand domain public.timestamp_ord_ope_query (term-only; no `c`). + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope_query' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope_query AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'op' + AND NOT (VALUE ? 'c') + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope_query IS 'EQL timestamp query operand (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file v3/scalars/timestamp/timestamp_types.sql +--! @brief Encrypted-domain types for timestamp. + +DO $$ +BEGIN + --! @brief Encrypted domain public.timestamp. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp IS 'EQL encrypted timestamp (storage only)'; + + --! @brief Encrypted domain public.timestamp_eq. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_eq' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_eq AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'hm' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_eq IS 'EQL encrypted timestamp (equality)'; + + --! @brief Encrypted domain public.timestamp_ord_ore. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ore' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ore AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'ob' + AND jsonb_typeof(VALUE -> 'ob') = 'array' + AND jsonb_array_length(VALUE -> 'ob') > 0 + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; + + --! @brief Encrypted domain public.timestamp_ord_ope. + IF NOT EXISTS ( + SELECT 1 FROM pg_type + WHERE typname = 'timestamp_ord_ope' AND typnamespace = 'public'::regnamespace + ) THEN + CREATE DOMAIN public.timestamp_ord_ope AS jsonb + CHECK ( + jsonb_typeof(VALUE) = 'object' + AND VALUE ? 'v' + AND VALUE ? 'i' + AND VALUE ? 'c' + AND VALUE ? 'op' + AND VALUE->>'v' = '3' + ); + END IF; + + COMMENT ON DOMAIN public.timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; +END +$$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql +--! @brief Functions for public.timestamp_eq. + +--! @brief Index extractor for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.timestamp_eq) $$; + +--! @brief Operator wrapper for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a::public.timestamp_eq) <> eql_v3.eq_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_eq, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_eq) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector text) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_eq, selector integer) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return public.timestamp_eq +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_eq) +RETURNS public.timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_eq, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param selector public.timestamp_eq +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_eq) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_eq, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_eq, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_eq, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_eq, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_eq, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a public.timestamp_eq +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_eq, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_eq. +--! @param a jsonb +--! @param b public.timestamp_eq +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_eq) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_eq'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql +--! @brief Operators for public.timestamp_eq. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_eq, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_eq, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_eq +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_query_functions.sql +--! @brief Functions for public.timestamp_eq_query. + +--! @brief Index extractor for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @return eql_v3_internal.hmac_256 +CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq_query) +RETURNS eql_v3_internal.hmac_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq +--! @param b public.timestamp_eq_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_eq_query. +--! @param a public.timestamp_eq_query +--! @param b public.timestamp_eq +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_eq_query, b public.timestamp_eq) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_eq_query_operators.sql +--! @brief Operators for public.timestamp_eq_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_functions.sql +--! @brief Functions for public.timestamp. + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector text +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector text) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector integer +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp, selector integer) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param selector public.timestamp +--! @return public.timestamp +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp) +RETURNS public.timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param selector public.timestamp +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b public.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b public.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a public.timestamp +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp. +--! @param a jsonb +--! @param b public.timestamp +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_operators.sql +--! @brief Operators for public.timestamp. + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = public.timestamp +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql +--! @brief Functions for public.timestamp_ord. + +--! @brief Index extractor for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.timestamp_ord) $$; + +--! @brief Operator wrapper for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector text) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord, selector integer) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord) +RETURNS public.timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param selector public.timestamp_ord +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a public.timestamp_ord +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord. +--! @param a jsonb +--! @param b public.timestamp_ord +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql +--! @brief Functions for public.timestamp_ord_ope. + +--! @brief Index extractor for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b::public.timestamp_ord_ope) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a::public.timestamp_ord_ope) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ope, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ope) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector text +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector text) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector integer +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ope, selector integer) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param selector public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ope, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param selector public.timestamp_ord_ope +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ope) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ope, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ope, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ope, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ope, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ope, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b public.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a public.timestamp_ord_ope +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ope, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ope. +--! @param a jsonb +--! @param b public.timestamp_ord_ope +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ope) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ope'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql +--! @brief Operators for public.timestamp_ord_ope. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ope, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ope +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ope. + +--! @brief State function for min on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord_ope. +--! @param state public.timestamp_ord_ope +--! @param value public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ope, value public.timestamp_ord_ope) +RETURNS public.timestamp_ord_ope +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord_ope. +--! @param input public.timestamp_ord_ope +--! @return public.timestamp_ord_ope +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ope) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ope, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_functions.sql +--! @brief Functions for public.timestamp_ord_ope_query. + +--! @brief Index extractor for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @return eql_v3_internal.ope_cllw +CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope_query) +RETURNS eql_v3_internal.ope_cllw +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope +--! @param b public.timestamp_ord_ope_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ope_query. +--! @param a public.timestamp_ord_ope_query +--! @param b public.timestamp_ord_ope +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ope_query_operators.sql +--! @brief Operators for public.timestamp_ord_ope_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql +--! @brief Operators for public.timestamp_ord. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql +--! @brief Aggregates for public.timestamp_ord. + +--! @brief State function for min on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.min(public.timestamp_ord) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord. +--! @param state public.timestamp_ord +--! @param value public.timestamp_ord +--! @return public.timestamp_ord +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord, value public.timestamp_ord) +RETURNS public.timestamp_ord +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord. +--! @param input public.timestamp_ord +--! @return public.timestamp_ord +CREATE AGGREGATE eql_v3.max(public.timestamp_ord) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql +--! @brief Functions for public.timestamp_ord_ore. + +--! @brief Index extractor for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.timestamp_ord_ore) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a::public.timestamp_ord_ore) >= eql_v3.ord_term(b) $$; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a public.timestamp_ord_ore, b jsonb) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.timestamp_ord_ore) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector text) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a public.timestamp_ord_ore, selector integer) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector text +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector text) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param selector integer +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a public.timestamp_ord_ore, selector integer) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param selector public.timestamp_ord_ore +--! @return text +CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.timestamp_ord_ore) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return boolean +CREATE FUNCTION eql_v3_internal."?"(a public.timestamp_ord_ore, b text) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?|"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return boolean +CREATE FUNCTION eql_v3_internal."?&"(a public.timestamp_ord_ore, b text[]) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@?"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonpath +--! @return boolean +CREATE FUNCTION eql_v3_internal."@@"(a public.timestamp_ord_ore, b jsonpath) +RETURNS boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#>"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return text +CREATE FUNCTION eql_v3_internal."#>>"(a public.timestamp_ord_ore, b text[]) +RETURNS text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b integer +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b integer) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b text[] +--! @return jsonb +CREATE FUNCTION eql_v3_internal."#-"(a public.timestamp_ord_ore, b text[]) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a public.timestamp_ord_ore +--! @param b jsonb +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a public.timestamp_ord_ore, b jsonb) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; + +--! @brief Unsupported operator blocker for public.timestamp_ord_ore. +--! @param a jsonb +--! @param b public.timestamp_ord_ore +--! @return jsonb +CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.timestamp_ord_ore) +RETURNS jsonb IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.timestamp_ord_ore'; END; $$ +LANGUAGE plpgsql; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql +--! @brief Operators for public.timestamp_ord_ore. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR @> ( + FUNCTION = eql_v3_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR <@ ( + FUNCTION = eql_v3_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR -> ( + FUNCTION = eql_v3_internal."->", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR ->> ( + FUNCTION = eql_v3_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR ? ( + FUNCTION = eql_v3_internal."?", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR ?| ( + FUNCTION = eql_v3_internal."?|", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR ?& ( + FUNCTION = eql_v3_internal."?&", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR @? ( + FUNCTION = eql_v3_internal."@?", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR @@ ( + FUNCTION = eql_v3_internal."@@", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonpath +); + +CREATE OPERATOR #> ( + FUNCTION = eql_v3_internal."#>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #>> ( + FUNCTION = eql_v3_internal."#>>", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = integer +); + +CREATE OPERATOR - ( + FUNCTION = eql_v3_internal."-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR #- ( + FUNCTION = eql_v3_internal."#-", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = text[] +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = public.timestamp_ord_ore, RIGHTARG = jsonb +); + +CREATE OPERATOR || ( + FUNCTION = eql_v3_internal."||", + LEFTARG = jsonb, RIGHTARG = public.timestamp_ord_ore +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql +--! @brief Aggregates for public.timestamp_ord_ore. + +--! @brief State function for min on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.min_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value < state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief min aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.min(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.min_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.min_sfunc, + parallel = safe +); + +--! @brief State function for max on public.timestamp_ord_ore. +--! @param state public.timestamp_ord_ore +--! @param value public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE FUNCTION eql_v3_internal.max_sfunc(state public.timestamp_ord_ore, value public.timestamp_ord_ore) +RETURNS public.timestamp_ord_ore +LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE +SET search_path = pg_catalog, extensions, public +AS $$ +BEGIN + IF value > state THEN + RETURN value; + END IF; + RETURN state; +END; +$$; + +--! @brief max aggregate for public.timestamp_ord_ore. +--! @param input public.timestamp_ord_ore +--! @return public.timestamp_ord_ore +CREATE AGGREGATE eql_v3.max(public.timestamp_ord_ore) ( + sfunc = eql_v3_internal.max_sfunc, + stype = public.timestamp_ord_ore, + combinefunc = eql_v3_internal.max_sfunc, + parallel = safe +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_functions.sql +--! @brief Functions for public.timestamp_ord_ore_query. + +--! @brief Index extractor for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore +--! @param b public.timestamp_ord_ore_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_ore_query. +--! @param a public.timestamp_ord_ore_query +--! @param b public.timestamp_ord_ore +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_ore_query_operators.sql +--! @brief Operators for public.timestamp_ord_ore_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_query_functions.sql +--! @brief Functions for public.timestamp_ord_query. + +--! @brief Index extractor for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @return eql_v3_internal.ore_block_256 +CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_query) +RETURNS eql_v3_internal.ore_block_256 +LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord +--! @param b public.timestamp_ord_query +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord_query) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; + +--! @brief Operator wrapper for public.timestamp_ord_query. +--! @param a public.timestamp_ord_query +--! @param b public.timestamp_ord +--! @return boolean +CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_query, b public.timestamp_ord) +RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE +AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +-- AUTOMATICALLY GENERATED FILE. + +--! @file encrypted_domain/timestamp/timestamp_ord_query_operators.sql +--! @brief Operators for public.timestamp_ord_query. + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR = ( + FUNCTION = eql_v3.eq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR <> ( + FUNCTION = eql_v3.neq, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR < ( + FUNCTION = eql_v3.lt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR <= ( + FUNCTION = eql_v3.lte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR > ( + FUNCTION = eql_v3.gt, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); + +CREATE OPERATOR >= ( + FUNCTION = eql_v3.gte, + LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord, + COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel +); +--! @file pin_search_path_v3.sql +--! @brief Post-install: pin search_path on every eql_v3.* function. +--! +--! 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, including public +--! user-column domains) 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. 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') + 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 = 'public' + OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + ) + ) + ) + -- Comment-marker fallback for hand-written inline-critical extension + -- functions that take no domain argument. + AND NOT EXISTS ( + SELECT 1 FROM pg_catalog.pg_description d + WHERE d.objoid = p.oid + AND d.classoid = 'pg_catalog.pg_proc'::regclass + AND d.description LIKE 'eql-inline-critical%' + ) + LOOP + EXECUTE pg_catalog.format( + 'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public', + fn_oid::regprocedure + ); + END LOOP; +END $$; diff --git a/packages/cli/tests/e2e/runner-aware-help.e2e.test.ts b/packages/cli/tests/e2e/runner-aware-help.e2e.test.ts index 786f9cae..e8b1fa09 100644 --- a/packages/cli/tests/e2e/runner-aware-help.e2e.test.ts +++ b/packages/cli/tests/e2e/runner-aware-help.e2e.test.ts @@ -37,7 +37,7 @@ describe('--help — runner-aware Usage + Examples', () => { expect(r.output).toContain(`Usage: ${label} stash`) // At least one of the Examples lines must surface the same runner. expect(r.output).toContain(`${label} stash init`) - expect(r.output).toContain(`${label} stash db install`) + expect(r.output).toContain(`${label} stash eql install`) }) }) diff --git a/packages/cli/tests/e2e/smoke.e2e.test.ts b/packages/cli/tests/e2e/smoke.e2e.test.ts index 777f4e5a..9d6c5ef9 100644 --- a/packages/cli/tests/e2e/smoke.e2e.test.ts +++ b/packages/cli/tests/e2e/smoke.e2e.test.ts @@ -22,7 +22,7 @@ describe('stash CLI — non-interactive smoke', () => { // Command-list items — these are the literal command names users type, not // copy strings, so they stay inline. expect(r.output).toContain('init') - expect(r.output).toContain('db install') + expect(r.output).toContain('eql install') // The dotenv "injected env" banner regression guard lives in the // dedicated test below — this cwd has no .env file, so a bare // `not.toContain('injected env')` here would pass vacuously. diff --git a/packages/wizard/README.md b/packages/wizard/README.md index 5b9bd8b3..89965ce4 100644 --- a/packages/wizard/README.md +++ b/packages/wizard/README.md @@ -19,9 +19,9 @@ bunx @cipherstash/wizard # bun Before running the wizard, your project should have: -- `stash` available (the wizard shells out to `stash db install` / +- `stash` available (the wizard shells out to `stash eql install` / `db push` after the agent finishes editing) -- A `stash.config.ts` (or the wizard will run `stash db install` to scaffold one) +- A `stash.config.ts` (or the wizard will run `stash eql install` to scaffold one) - A reachable database via `DATABASE_URL` - An authenticated CipherStash session (`stash auth login`) @@ -32,7 +32,7 @@ Before running the wizard, your project should have: 3. Prompts you to pick the tables and columns to encrypt. 4. Hands a surgical prompt to the Claude Agent SDK, which edits your schema and call sites to use `@cipherstash/stack`'s encryption APIs. -5. Runs deterministic post-agent steps: package install, `db install`, +5. Runs deterministic post-agent steps: package install, `eql install`, `db push`, framework-specific migrations. 6. Reports remaining call sites that need `encryptModel` / `decryptModel` wiring. diff --git a/packages/wizard/src/__tests__/post-agent.test.ts b/packages/wizard/src/__tests__/post-agent.test.ts index a0408632..2cf0788b 100644 --- a/packages/wizard/src/__tests__/post-agent.test.ts +++ b/packages/wizard/src/__tests__/post-agent.test.ts @@ -36,7 +36,7 @@ describe('runPostAgentSteps execution commands', () => { const commands = vi .mocked(childProcess.execSync) .mock.calls.map((c) => c[0] as string) - expect(commands).toContain('bunx stash db install') + expect(commands).toContain('bunx stash eql install') expect(commands).toContain('bunx stash db push') // Sanity: no leftover npx forms for the cipherstash binaries. for (const cmd of commands) { @@ -59,7 +59,7 @@ describe('runPostAgentSteps execution commands', () => { .mocked(childProcess.execSync) .mock.calls.map((c) => c[0] as string) expect(commands).toContain('bunx stash db push') - expect(commands).not.toContain('bunx stash db install') + expect(commands).not.toContain('bunx stash eql install') }) it('falls back to npx when packageManager is undefined and usesProxy=true', async () => { @@ -76,7 +76,7 @@ describe('runPostAgentSteps execution commands', () => { const commands = vi .mocked(childProcess.execSync) .mock.calls.map((c) => c[0] as string) - expect(commands).toContain('npx stash db install') + expect(commands).toContain('npx stash eql install') expect(commands).toContain('npx stash db push') }) @@ -96,6 +96,6 @@ describe('runPostAgentSteps execution commands', () => { .mocked(childProcess.execSync) .mock.calls.map((c) => c[0] as string) expect(commands).not.toContain('bunx stash db push') - expect(commands).toContain('bunx stash db install') + expect(commands).toContain('bunx stash eql install') }) }) diff --git a/packages/wizard/src/__tests__/prerequisites.test.ts b/packages/wizard/src/__tests__/prerequisites.test.ts index 7f80cd6d..f57fddb3 100644 --- a/packages/wizard/src/__tests__/prerequisites.test.ts +++ b/packages/wizard/src/__tests__/prerequisites.test.ts @@ -40,7 +40,7 @@ describe('checkPrerequisites missing-list copy', () => { const r = await checkPrerequisites(tmp) expect(r.ok).toBe(false) expect(r.missing.join('\n')).toContain('Run: bunx stash auth login') - expect(r.missing.join('\n')).toContain('Run: bunx stash db install') + expect(r.missing.join('\n')).toContain('Run: bunx stash eql install') expect(r.missing.join('\n')).not.toMatch(/\bnpx\b/) }) diff --git a/packages/wizard/src/agent/__tests__/interface.test.ts b/packages/wizard/src/agent/__tests__/interface.test.ts index 755c463b..a14be3d6 100644 --- a/packages/wizard/src/agent/__tests__/interface.test.ts +++ b/packages/wizard/src/agent/__tests__/interface.test.ts @@ -21,10 +21,10 @@ describe('wizardCanUseTool — DLX command allowlist', () => { } }) - it('allows stash db with npx, bunx, pnpm dlx, yarn dlx', () => { + it('allows stash eql with npx, bunx, pnpm dlx, yarn dlx', () => { for (const runner of ['npx', 'bunx', 'pnpm dlx', 'yarn dlx']) { const result = wizardCanUseTool('Bash', { - command: `${runner} stash db install`, + command: `${runner} stash eql install`, }) expect(result).toBe(true) } @@ -75,8 +75,14 @@ describe('wizardCanUseTool — DLX command allowlist', () => { }) }) - describe('allows stash db commands', () => { - it('allows stash db install', () => { + describe('allows stash db / eql commands', () => { + it('allows stash eql install', () => { + expect(wizardCanUseTool('Bash', { command: 'stash eql install' })).toBe( + true, + ) + }) + + it('allows the deprecated stash db install alias', () => { expect(wizardCanUseTool('Bash', { command: 'stash db install' })).toBe( true, ) diff --git a/packages/wizard/src/agent/interface.ts b/packages/wizard/src/agent/interface.ts index d97df7be..2c1eceac 100644 --- a/packages/wizard/src/agent/interface.ts +++ b/packages/wizard/src/agent/interface.ts @@ -52,7 +52,12 @@ const RUNNER_PREFIXES = Object.values(PACKAGE_MANAGERS).map( ) /** Tools allowed to run via any DLX runner. */ -const ALLOWED_DLX_TOOLS = ['drizzle-kit', 'tsc', 'stash db'] as const +const ALLOWED_DLX_TOOLS = [ + 'drizzle-kit', + 'tsc', + 'stash db', + 'stash eql', +] as const /** Allowed Bash commands — whitelist approach. */ const ALLOWED_BASH_COMMANDS = [ @@ -74,6 +79,7 @@ const ALLOWED_BASH_COMMANDS = [ 'bun run', // Build & validation 'stash db', + 'stash eql', ] /** diff --git a/packages/wizard/src/lib/post-agent.ts b/packages/wizard/src/lib/post-agent.ts index e7290535..34c18f2a 100644 --- a/packages/wizard/src/lib/post-agent.ts +++ b/packages/wizard/src/lib/post-agent.ts @@ -41,14 +41,14 @@ export async function runPostAgentSteps(opts: PostAgentOptions): Promise { cwd, ) - // Step 2: Run runner stash db install if the project doesn't yet - // have a stash.config.ts. `db install` scaffolds the config and installs + // Step 2: Run runner stash eql install if the project doesn't yet + // have a stash.config.ts. `eql install` scaffolds the config and installs // EQL in a single step (CIP-2986). if (!gathered.hasStashConfig) { await runStep( - `Running ${runner} stash db install...`, - `${runner} stash db install complete`, - `${runner} stash db install`, + `Running ${runner} stash eql install...`, + `${runner} stash eql install complete`, + `${runner} stash eql install`, cwd, ) } diff --git a/packages/wizard/src/lib/prerequisites.ts b/packages/wizard/src/lib/prerequisites.ts index f92e7f60..fcf234ac 100644 --- a/packages/wizard/src/lib/prerequisites.ts +++ b/packages/wizard/src/lib/prerequisites.ts @@ -26,7 +26,7 @@ export async function checkPrerequisites( } if (!findStashConfig(cwd)) { - missing.push(`No stash.config.ts found. Run: ${runner} stash db install`) + missing.push(`No stash.config.ts found. Run: ${runner} stash eql install`) } return { ok: missing.length === 0, missing } diff --git a/packages/wizard/src/lib/rewrite-migrations.ts b/packages/wizard/src/lib/rewrite-migrations.ts index ad12558a..ea254486 100644 --- a/packages/wizard/src/lib/rewrite-migrations.ts +++ b/packages/wizard/src/lib/rewrite-migrations.ts @@ -19,7 +19,7 @@ import { join } from 'node:path' * - $2: column name (without quotes) * * Note: a copy of this lives in `stash` (`db/rewrite-migrations.ts`) - * because cli's `db install --drizzle` uses the same fix. Both copies are + * because cli's `eql install --drizzle` uses the same fix. Both copies are * tightly coupled to drizzle-kit's output format — if drizzle-kit changes, * both need to be updated together. */ diff --git a/packages/wizard/src/run.ts b/packages/wizard/src/run.ts index 636dc7df..87259688 100644 --- a/packages/wizard/src/run.ts +++ b/packages/wizard/src/run.ts @@ -240,7 +240,7 @@ export async function run(options: RunOptions) { }) changelog.phase( 'Post-agent steps complete', - 'Package install, `db install`, `db push`, and migrations finished.', + 'Package install, `eql install`, `db push`, and migrations finished.', ) const scanResult = await scanPromise From 079d3231a89cc1609eba5a6ddadb165d7882673c Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Wed, 8 Jul 2026 16:39:27 +1000 Subject: [PATCH 4/9] docs(stack,cli): reconcile living docs to `stash eql install` + document --eql-version Update the stash-cli skill and @cipherstash/migrate README to the renamed `stash eql install` command (keeping `stash db install` documented as the deprecated alias), and document the new `--eql-version <2|3>` install flag and its v3 direct-install-only constraints in the skill. Re-expressed from james/cip-3291-bigint-stack 64fdeb2c/d15414a5 docs. Historical CHANGELOGs and dated design docs are left as point-in-time records; the base already migrated the domain surface to public.*. --- packages/migrate/README.md | 4 ++-- skills/stash-cli/SKILL.md | 41 +++++++++++++++++++++----------------- 2 files changed, 25 insertions(+), 20 deletions(-) diff --git a/packages/migrate/README.md b/packages/migrate/README.md index 2c7b38c4..37eb8a5c 100644 --- a/packages/migrate/README.md +++ b/packages/migrate/README.md @@ -12,7 +12,7 @@ Each column walks through these phases: schema-added → dual-writing → backfilling → backfilled → cut-over → dropped ``` -State is tracked in an append-only `cipherstash.cs_migrations` table installed by `stash db 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. +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. ## API @@ -32,7 +32,7 @@ import { ### `installMigrationsSchema(client)` -Creates `cipherstash.cs_migrations` idempotently. Normally called by `stash db install`. +Creates `cipherstash.cs_migrations` idempotently. Normally called by `stash eql install`. ### `runBackfill({ db, encryptionClient, tableSchema, tableName, plaintextColumn, encryptedColumn, pkColumn, schemaColumnKey, chunkSize?, signal?, onProgress? })` diff --git a/skills/stash-cli/SKILL.md b/skills/stash-cli/SKILL.md index 7a07f467..eb33752d 100644 --- a/skills/stash-cli/SKILL.md +++ b/skills/stash-cli/SKILL.md @@ -90,7 +90,7 @@ export default defineConfig({ }) ``` -`db install` will scaffold this file for you if it's missing. +`eql install` will scaffold this file for you if it's missing. ### Config options @@ -130,7 +130,7 @@ Init is the **scaffold** save-point. It does mechanical setup only — no agent 2. **Resolve database** — picks up `DATABASE_URL` from `.env`/`.env.local` or prompts for it. Verifies the connection. 3. **Build schema** — auto-detects your framework (Drizzle from `drizzle.config.*` / `drizzle-orm` / `drizzle-kit` in `package.json`; Supabase from the `DATABASE_URL` host) and silently writes a placeholder client to `./src/encryption/index.ts`. Only prompts you if a file already exists at that path. 4. **Install dependencies** — single combined prompt for `@cipherstash/stack` and `stash`. Skipped entirely when both are already in `node_modules`. -5. **Install EQL** — runs the equivalent of `stash db install` against the resolved database (Drizzle migration, Supabase migration, or direct, per detection). Skipped if EQL is already installed. +5. **Install EQL** — runs the equivalent of `stash eql install` against the resolved database (Drizzle migration, Supabase migration, or direct, per detection). Skipped if EQL is already installed. 6. **Gather context** — detects available coding agents (Claude Code, Codex, Cursor, Windsurf, Cline) and writes `.cipherstash/context.json` with integration, package manager, schemas, env keys, and detected agents. When init finishes, it prints a checkmark panel of completed phases and an interactive **chain prompt** (default-yes): *"Continue to `stash plan` now to draft your encryption plan?"* Yes auto-launches `stash plan`. No prints "Next: run `stash plan` to draft your encryption plan." Non-TTY (CI, pipes) skips the prompt and prints the hint. @@ -257,20 +257,22 @@ stash auth login Opens a browser-based device code flow and saves a token to `~/.cipherstash/auth.json`. Database-touching commands check for this file before running. -### `db install` — Configure the database and install EQL extensions +### `eql install` — Configure the database and install EQL extensions ```bash -stash db install -stash db install --supabase -stash db install --supabase --migration -stash db install --supabase --direct -stash db install --drizzle -stash db install --force +stash eql install +stash eql install --supabase +stash eql install --supabase --migration +stash eql install --supabase --direct +stash eql install --drizzle +stash eql install --force ``` -`stash init` runs `db install` automatically as part of its EQL install phase. Run `db install` directly when you skipped init, when you need flags init doesn't expose (`--migration`, `--migrations-dir`, `--exclude-operator-family`), or when re-installing/upgrading EQL on its own. +`stash db install` is a deprecated alias for this command — it still works but prints a deprecation warning. Always use `eql install` in new instructions. -`db install` is the single command that gets a project from zero to installed EQL: +`stash init` runs `eql install` automatically as part of its EQL install phase. Run `eql install` directly when you skipped init, when you need flags init doesn't expose (`--migration`, `--migrations-dir`, `--exclude-operator-family`), or when re-installing/upgrading EQL on its own. + +`eql install` is the single command that gets a project from zero to installed EQL: 1. Scaffolds `stash.config.ts` if missing (auto-detects an existing client file at common locations, otherwise prompts). 2. Loads the config. @@ -295,10 +297,13 @@ stash db install --force | `--migration` | Write the EQL SQL into a Supabase migration file (requires `--supabase`) | | `--direct` | Run the EQL SQL directly against the database (requires `--supabase`; mutually exclusive with `--migration`) | | `--migrations-dir ` | Override the Supabase migrations directory (requires `--supabase`; default: `supabase/migrations`) | +| `--eql-version <2\|3>` | EQL generation to install (default: `2`). `3` installs the native concrete-domain schema (`public.*` type domains, `eql_v3` operators, `eql_v3_internal` constructors) | `--migration`, `--direct`, and `--migrations-dir` only make sense in the Supabase flow and require `--supabase` to be passed explicitly. They never auto-enable `--supabase`. -#### `db install --drizzle` +`--eql-version 3` currently installs via the direct path only — it rejects `--drizzle`, `--migration`, `--migrations-dir`, and `--latest`. Bundles are vendored (no public v3 release artifacts yet), so `--latest` is v2-only. + +#### `eql install --drizzle` When `--drizzle` is passed, the CLI: 1. Runs `drizzle-kit generate --custom --name=` to scaffold an empty migration. @@ -307,7 +312,7 @@ When `--drizzle` is passed, the CLI: You then run `npx drizzle-kit migrate` to apply it. Requires `drizzle-kit` as a dev dependency. -#### `db install --supabase --migration` +#### `eql install --supabase --migration` Writes the EQL SQL to `supabase/migrations/00000000000000_cipherstash_eql.sql`. The all-zero timestamp ensures this migration runs before any user migrations that reference `eql_v2_encrypted`. Run `supabase db reset` (local) or `supabase migration up` (remote) to apply it. @@ -331,7 +336,7 @@ stash db upgrade --latest | `--exclude-operator-family` | Skip operator family creation | | `--latest` | Fetch latest EQL from GitHub instead of bundled | -The EQL install SQL is idempotent and safe to re-run. The command checks the current version, re-runs the install SQL, then reports the new version. If EQL is not installed, it suggests running `db install` instead. +The EQL install SQL is idempotent and safe to re-run. The command checks the current version, re-runs the install SQL, then reports the new version. If EQL is not installed, it suggests running `eql install` instead. ### `db validate` — Validate encryption schema @@ -437,7 +442,7 @@ Reports: stash db test-connection ``` -Verifies the database URL in your config is valid and the database is reachable. Reports the database name, connected role, and PostgreSQL server version. Useful for debugging connection issues before running `db install`. +Verifies the database URL in your config is valid and the database is reachable. Reports the database name, connected role, and PostgreSQL server version. Useful for debugging connection issues before running `eql install`. ### `db migrate` — Run pending encrypt config migrations @@ -451,7 +456,7 @@ Not yet implemented — placeholder for future encrypt-config migration tooling. The `encrypt` group is the cutover-step toolset: it runs the database-side work that takes an existing plaintext column the rest of the way to encrypted, after the encryption-rollout PR is deployed and dual-writes are live in production. The internal event log uses `schema-added → dual-writing → backfilling → backfilled → cut-over → dropped` as machine-readable phase names; the user-facing story is the rollout/cutover model documented in the `stash-encryption` skill. -It drives the `@cipherstash/migrate` library, which records every transition in a `cipherstash.cs_migrations` table (installed by `stash db install`) and reads the user's intent from `.cipherstash/migrations.json`. This section documents the CLI surface. +It drives the `@cipherstash/migrate` library, which records every transition in a `cipherstash.cs_migrations` table (installed by `stash eql install`) and reads the user's intent from `.cipherstash/migrations.json`. This section documents the CLI surface. The examples below show the bare `stash` form, which works after `stash init` adds the CLI as a project dev dep. See the "CLI Usage" section above for how to invoke it through your package manager before that. @@ -639,7 +644,7 @@ if (await installer.isInstalled()) { - Node.js >= 22 - PostgreSQL database with sufficient permissions (see `checkPermissions()`) -- A `stash.config.ts` file with a valid `databaseUrl` (or run `stash init` / `stash db install` to scaffold it) +- A `stash.config.ts` file with a valid `databaseUrl` (or run `stash init` / `stash eql install` to scaffold it) - Peer dependency: `@cipherstash/stack` >= 0.6.0 ## Common issues @@ -650,7 +655,7 @@ The database role needs `CREATE` privileges on the database and public schema, o ### Config not found -`stash.config.ts` must be in the project root or a parent directory. The file must `export default defineConfig(...)`. The fastest fix is `stash init`, which scaffolds the config (and authenticates, installs deps, installs EQL, and writes `.cipherstash/context.json` in the same run). For a CLI-only setup, `stash db install` also scaffolds the config. +`stash.config.ts` must be in the project root or a parent directory. The file must `export default defineConfig(...)`. The fastest fix is `stash init`, which scaffolds the config (and authenticates, installs deps, installs EQL, and writes `.cipherstash/context.json` in the same run). For a CLI-only setup, `stash eql install` also scaffolds the config. ### Supabase environments From 4d54c27e9a6c77382b6074d9dea0af2a94739bca Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 9 Jul 2026 11:19:48 +1000 Subject: [PATCH 5/9] test(stack): compare bigint ORE samples numerically, not lexicographically The plaintext comparator fell through to a String() compare for `bigint` samples, so the two bigint ORE domains derived a numerically wrong expected order (String(-42n) < String(-9223372036854775808n) while -42n > -9.2e18n). The ORE ciphertext order was correct; only the expectation was wrong. --- .../__tests__/v3-matrix/matrix-live-pg.test.ts | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) 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 5a69f32c..b58fe715 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live-pg.test.ts @@ -172,11 +172,20 @@ const MAX_ORDER_ROWS = Math.max( ) /** Plaintext ordering used to derive the EXPECTED ORE order per domain. - * Dates compare by instant, numbers numerically, strings by code point (ORE - * text order is byte order, which matches JS `<` for the ASCII samples here). */ + * 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 From dafcb023eca8143e58ff4cee90a7db7b2fdab04a Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 9 Jul 2026 11:19:48 +1000 Subject: [PATCH 6/9] docs(cli,migrate): reference #585 for v3 flag gaps, scope migrate README to v2 Addresses review feedback on #583: - Note that gating --drizzle and --latest behind --eql-version 2 is tracked in #585, at both sites where v3 declines the v2-only path. - State plainly that @cipherstash/migrate targets EQL v2, that v3 is opt-in and direct-install-only, and that v3 columns are outside this lifecycle. --- packages/cli/src/commands/db/install.ts | 1 + packages/cli/src/installer/index.ts | 1 + packages/migrate/README.md | 2 ++ 3 files changed, 4 insertions(+) diff --git a/packages/cli/src/commands/db/install.ts b/packages/cli/src/commands/db/install.ts index 67553887..d4e13447 100644 --- a/packages/cli/src/commands/db/install.ts +++ b/packages/cli/src/commands/db/install.ts @@ -122,6 +122,7 @@ export async function installCommand(options: InstallOptions) { // v3 supports the direct install path only. Explicit --drizzle/--migration // are rejected up-front by validateInstallFlags; auto-DETECTED drizzle or // migration modes fall back to direct here rather than erroring. + // Gating the v2-only paths behind --eql-version 2 is tracked in #585. if (eqlVersion === 3 && resolved.drizzle) { p.log.info( 'EQL v3 does not support the Drizzle migration path yet — installing directly.', diff --git a/packages/cli/src/installer/index.ts b/packages/cli/src/installer/index.ts index be8352b5..bd75afa8 100644 --- a/packages/cli/src/installer/index.ts +++ b/packages/cli/src/installer/index.ts @@ -287,6 +287,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.', ) diff --git a/packages/migrate/README.md b/packages/migrate/README.md index 37eb8a5c..a4fa2959 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 From f14e2b5b515dbc0b2cf833889f2853911ec382be Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 9 Jul 2026 13:04:26 +1000 Subject: [PATCH 7/9] fix(stack): reject out-of-range bigint on every encrypt path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit bigint domains map to Postgres int8, so a plaintext outside the signed 64-bit range cannot be stored. Add an i64-range check to the shared numeric guard (validateNumericValue / assertValidNumericValue) — the bigint analog of the existing NaN/Infinity guard — and thread it through the model / bulk-model encrypt path, which built the FFI payload directly and validated nothing. Also extend the match-index guard to reject bigint. protect-ffi 0.28 already i64-bounds-checks (encodeBigIntPlaintext throws a RangeError on every encrypt entry), so this is defense-in-depth: it fails earlier, before the network call, with a typed EncryptionError / Result. Correct the stale "enforced at the protect-ffi boundary" comments to reflect that the SDK now enforces it too. Matrix parity: widen DomainSpec.errorSamples to accept bigint and add BIGINT_ERR (i64::MAX + 1, i64::MIN - 1) to the four bigint domains so the live suite exercises rejection alongside the numeric families. Extend the offline guard suite with the single, lock-context and model/bulk bigint rejection cases. --- .../encrypt-lock-context-guards.test.ts | 105 ++++++++++++++++++ packages/stack/__tests__/v3-matrix/catalog.ts | 25 +++-- .../__tests__/v3-matrix/matrix-live.test.ts | 7 +- .../src/encryption/helpers/model-helpers.ts | 16 ++- .../src/encryption/helpers/validation.ts | 47 +++++++- packages/stack/src/eql/v3/columns.ts | 7 +- 6 files changed, 186 insertions(+), 21 deletions(-) diff --git a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts index c610d608..f26be065 100644 --- a/packages/stack/__tests__/encrypt-lock-context-guards.test.ts +++ b/packages/stack/__tests__/encrypt-lock-context-guards.test.ts @@ -30,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'), })) @@ -41,6 +47,7 @@ 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 @@ -101,3 +108,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 client.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 client.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 client + .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 client.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 client.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 client.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__/v3-matrix/catalog.ts b/packages/stack/__tests__/v3-matrix/catalog.ts index b08e8686..c2dbf803 100644 --- a/packages/stack/__tests__/v3-matrix/catalog.ts +++ b/packages/stack/__tests__/v3-matrix/catalog.ts @@ -106,9 +106,11 @@ export type DomainSpec = Readonly<{ 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 }> /** @@ -179,9 +181,10 @@ 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 (enforced at the protect-ffi boundary): 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. +// 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, @@ -221,6 +224,10 @@ const NUM_ERR = [ 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 = { @@ -235,10 +242,10 @@ export const V3_MATRIX = { 'public.smallint_ord_ore': { builder: types.SmallintOrdOre, ColumnClass: EncryptedSmallintOrdOreColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, 'public.smallint_ord': { builder: types.SmallintOrd, ColumnClass: EncryptedSmallintOrdColumn, castAs: 'number', capabilities: ORD, indexes: ORE_IDX, samples: SMALLINT_S, errorSamples: NUM_ERR }, // bigint (int8) — native JS bigint round-trip on protect-ffi 0.28; ungated - 'public.bigint': { builder: types.Bigint, ColumnClass: EncryptedBigintColumn, castAs: 'bigint', capabilities: STORAGE, indexes: NONE, samples: BIGINT_S }, - 'public.bigint_eq': { builder: types.BigintEq, ColumnClass: EncryptedBigintEqColumn, castAs: 'bigint', capabilities: EQ, indexes: UNIQUE_IDX, samples: BIGINT_S }, - 'public.bigint_ord_ore': { builder: types.BigintOrdOre, ColumnClass: EncryptedBigintOrdOreColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S }, - 'public.bigint_ord': { builder: types.BigintOrd, ColumnClass: EncryptedBigintOrdColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S }, + 'public.bigint': { builder: types.Bigint, ColumnClass: EncryptedBigintColumn, castAs: 'bigint', capabilities: STORAGE, indexes: NONE, samples: BIGINT_S, errorSamples: BIGINT_ERR }, + 'public.bigint_eq': { builder: types.BigintEq, ColumnClass: EncryptedBigintEqColumn, castAs: 'bigint', capabilities: EQ, indexes: UNIQUE_IDX, samples: BIGINT_S, errorSamples: BIGINT_ERR }, + 'public.bigint_ord_ore': { builder: types.BigintOrdOre, ColumnClass: EncryptedBigintOrdOreColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S, errorSamples: BIGINT_ERR }, + 'public.bigint_ord': { builder: types.BigintOrd, ColumnClass: EncryptedBigintOrdColumn, castAs: 'bigint', capabilities: ORD, indexes: ORE_IDX, samples: BIGINT_S, errorSamples: BIGINT_ERR }, // date 'public.date': { builder: types.Date, ColumnClass: EncryptedDateColumn, castAs: 'date', capabilities: STORAGE, indexes: NONE, samples: DATE_S }, 'public.date_eq': { builder: types.DateEq, ColumnClass: EncryptedDateEqColumn, castAs: 'date', capabilities: EQ, indexes: UNIQUE_IDX, samples: DATE_S }, diff --git a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts index c0082fbf..5e66867b 100644 --- a/packages/stack/__tests__/v3-matrix/matrix-live.test.ts +++ b/packages/stack/__tests__/v3-matrix/matrix-live.test.ts @@ -107,9 +107,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/src/encryption/helpers/model-helpers.ts b/packages/stack/src/encryption/helpers/model-helpers.ts index 1ba3997a..1d7eec4f 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 ab411040..ebdf609a 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.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/eql/v3/columns.ts b/packages/stack/src/eql/v3/columns.ts index 77329211..2753ef92 100644 --- a/packages/stack/src/eql/v3/columns.ts +++ b/packages/stack/src/eql/v3/columns.ts @@ -153,9 +153,10 @@ export const SMALLINT_ORD = { } as const // bigint (int8) domains. Plaintext is a JS `bigint` (always decrypts to -// `bigint`); bounds are the full i64 range, enforced at the protect-ffi -// boundary, which round-trips a native bigint losslessly. (`*_ord_ope` -// variants are out of scope — CIP-3403.) +// `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.bigint', castAs: 'bigint', From 8f93fb376bef2b84f945983232371760d8b531e5 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 9 Jul 2026 13:04:26 +1000 Subject: [PATCH 8/9] feat(stack): accept bigint on the WASM entry point MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit WasmPlaintext omitted a bigint arm, so bigint (int8) columns were unusable on the wasm / edge entry point even though protect-ffi 0.28's wasm build already carries a native bigint across the boundary (encode_plaintext on encrypt, js_sys::BigInt on decrypt). Widen the union — a type-only change, the runtime is already supported upstream — and add a type-level test. --- .../stack/__tests__/wasm-plaintext.test-d.ts | 21 +++++++++++++++++++ packages/stack/src/wasm-inline.ts | 10 +++++++-- 2 files changed, 29 insertions(+), 2 deletions(-) create mode 100644 packages/stack/__tests__/wasm-plaintext.test-d.ts 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 00000000..ab487e84 --- /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/src/wasm-inline.ts b/packages/stack/src/wasm-inline.ts index 9fc36a4b..7e9d7b0c 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 From a72a11371a0673764fca254718555c92a0edd200 Mon Sep 17 00:00:00 2001 From: Toby Hede Date: Thu, 9 Jul 2026 13:04:26 +1000 Subject: [PATCH 9/9] fix(stack,drizzle): stop silently coercing bigint query values to strings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit toPlaintext fell through to String(value), so a bigint query value was encrypted as the text "1" and silently mismatched its column's bigint domain — data corruption the FFI could not catch, because the coercion happened before it. - stack (EQL v3): preserve the native bigint. The encryptQuery term type is Plaintext, which carries bigint, so protect-ffi 0.28 encrypts it against the int8 domain and i64-bounds-checks it. - @cipherstash/drizzle (EQL v2): the protect query term type is JsPlaintext | null and cannot carry a bigint, so reject loudly with a ProtectOperatorError instead of corrupting. Regression tests for both packages. --- packages/drizzle/__tests__/operators.test.ts | 30 ++++++++++ packages/drizzle/src/pg/operators.ts | 11 ++++ .../drizzle-operators-bigint.test.ts | 59 +++++++++++++++++++ packages/stack/src/drizzle/operators.ts | 17 ++++-- 4 files changed, 113 insertions(+), 4 deletions(-) create mode 100644 packages/stack/__tests__/drizzle-operators-bigint.test.ts diff --git a/packages/drizzle/__tests__/operators.test.ts b/packages/drizzle/__tests__/operators.test.ts index 41b174b0..e88c75a4 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 8c0a2cf2..358bb331 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/stack/__tests__/drizzle-operators-bigint.test.ts b/packages/stack/__tests__/drizzle-operators-bigint.test.ts new file mode 100644 index 00000000..6e042a6b --- /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/src/drizzle/operators.ts b/packages/stack/src/drizzle/operators.ts index 0644d7de..c31e2ff0 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 }>