From a11f0c8a85a9d099bdd26735b8ad4f137573067b Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 12:29:01 -0600
Subject: [PATCH 01/21] feat(prisma-next): derive v3 domain catalog + codec ids
 from stack DOMAIN_REGISTRY

Codec ids are the DOMAIN_REGISTRY key verbatim (cipherstash/eql-v3/eql_v3_*@1)
per the GA eql_v3_* domain naming; json is a first-class exposed domain.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/src/v3/catalog.ts       | 102 +++++++++++++++++++
 packages/prisma-next/test/v3/catalog.test.ts |  90 ++++++++++++++++
 packages/stack/src/eql/v3/index.ts           |   6 ++
 3 files changed, 198 insertions(+)
 create mode 100644 packages/prisma-next/src/v3/catalog.ts
 create mode 100644 packages/prisma-next/test/v3/catalog.test.ts

diff --git a/packages/prisma-next/src/v3/catalog.ts b/packages/prisma-next/src/v3/catalog.ts
new file mode 100644
index 00000000..e56b837f
--- /dev/null
+++ b/packages/prisma-next/src/v3/catalog.ts
@@ -0,0 +1,102 @@
+/**
+ * v3 domain catalog — derived (never hand-maintained) from the imported
+ * `DOMAIN_REGISTRY`. For each bare domain name we probe its factory and read
+ * `getEqlType()` (the `public.*` native type), `getQueryCapabilities()`, and
+ * `build()` (`cast_as` + `indexes`) off the instance. Codec id is
+ * `cipherstash/eql-v3/${bareDomain}@1` where `bareDomain` is the registry key
+ * VERBATIM (only the `public.` schema qualifier is stripped). GA domains are
+ * `eql_v3_*`-prefixed, so ids read `cipherstash/eql-v3/eql_v3_text_search@1` —
+ * deliberately: the id is a mechanical bijection with the registry key, never a
+ * prettified transform decode would have to invert. The `eql-v3` token is a
+ * logical version tag, NOT the operator schema.
+ */
+import {
+  type AnyEncryptedV3Column,
+  DOMAIN_REGISTRY,
+  type QueryCapabilities,
+  type V3ColumnFactory,
+} from '@cipherstash/stack/eql/v3'
+
+export type V3CastAs =
+  | 'string'
+  | 'number'
+  | 'bigint'
+  | 'boolean'
+  | 'date'
+  | 'timestamp'
+  | 'json'
+
+export interface V3DomainMeta {
+  readonly nativeType: `public.${string}`
+  readonly bareDomain: string
+  readonly castAs: V3CastAs
+  readonly capabilities: QueryCapabilities
+  readonly indexes: Readonly<Record<string, unknown>>
+}
+
+export function toV3CodecId(bareDomain: string): string {
+  return `cipherstash/eql-v3/${bareDomain}@1`
+}
+
+const PROBE = '__probe__'
+
+function metaFor(bareDomain: string, factory: V3ColumnFactory): V3DomainMeta {
+  const column = factory(PROBE)
+  const built = column.build()
+  return {
+    nativeType: column.getEqlType(),
+    bareDomain,
+    castAs: built.cast_as as V3CastAs,
+    capabilities: column.getQueryCapabilities(),
+    indexes: built.indexes,
+  }
+}
+
+const registryEntries: ReadonlyArray<readonly [string, V3ColumnFactory]> =
+  Object.entries(DOMAIN_REGISTRY)
+
+const metaEntries: Array<readonly [string, V3DomainMeta]> = registryEntries.map(
+  ([bareDomain, factory]) => [toV3CodecId(bareDomain), metaFor(bareDomain, factory)] as const,
+)
+
+export const V3_DOMAIN_META_BY_CODEC_ID: ReadonlyMap<string, V3DomainMeta> = new Map(metaEntries)
+
+export const V3_CODEC_IDS: readonly string[] = metaEntries.map(([id]) => id)
+
+export const V3_FACTORY_BY_NATIVE_TYPE: ReadonlyMap<
+  string,
+  (name: string) => AnyEncryptedV3Column
+> = new Map(registryEntries.map(([, factory]) => [factory(PROBE).getEqlType(), factory] as const))
+
+export function isOrdOreDomain(bareDomain: string): boolean {
+  return bareDomain.endsWith('_ord_ore')
+}
+
+export const EXPOSED_DOMAIN_ENTRIES: ReadonlyArray<readonly [string, V3DomainMeta]> =
+  metaEntries.filter(([, meta]) => !isOrdOreDomain(meta.bareDomain))
+
+export function envelopeTypeNameForCastAs(
+  castAs: V3CastAs,
+):
+  | 'EncryptedString'
+  | 'EncryptedNumber'
+  | 'EncryptedBigInt'
+  | 'EncryptedDate'
+  | 'EncryptedBoolean'
+  | 'EncryptedJson' {
+  switch (castAs) {
+    case 'string':
+      return 'EncryptedString'
+    case 'number':
+      return 'EncryptedNumber'
+    case 'bigint':
+      return 'EncryptedBigInt'
+    case 'date':
+    case 'timestamp':
+      return 'EncryptedDate'
+    case 'boolean':
+      return 'EncryptedBoolean'
+    case 'json':
+      return 'EncryptedJson'
+  }
+}
diff --git a/packages/prisma-next/test/v3/catalog.test.ts b/packages/prisma-next/test/v3/catalog.test.ts
new file mode 100644
index 00000000..d04b0d89
--- /dev/null
+++ b/packages/prisma-next/test/v3/catalog.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+import {
+  EXPOSED_DOMAIN_ENTRIES,
+  envelopeTypeNameForCastAs,
+  isOrdOreDomain,
+  toV3CodecId,
+  V3_CODEC_IDS,
+  V3_DOMAIN_META_BY_CODEC_ID,
+  V3_FACTORY_BY_NATIVE_TYPE,
+} from '../../src/v3/catalog'
+
+describe('v3 catalog derivation', () => {
+  it('derives a concrete codec id per domain from the registry key verbatim', () => {
+    expect(toV3CodecId('eql_v3_text_search')).toBe('cipherstash/eql-v3/eql_v3_text_search@1')
+    expect(toV3CodecId('eql_v3_boolean')).toBe('cipherstash/eql-v3/eql_v3_boolean@1')
+  })
+
+  it('records the public.* native type (never eql_v3.*) for text_search with full caps', () => {
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_text_search@1')
+    expect(meta?.nativeType).toBe('public.eql_v3_text_search')
+    expect(meta?.nativeType.startsWith('public.')).toBe(true)
+    expect(meta?.castAs).toBe('string')
+    expect(meta?.capabilities).toEqual({ equality: true, orderAndRange: true, freeTextSearch: true })
+    expect(Object.keys(meta?.indexes ?? {}).sort()).toEqual(['match', 'ope', 'unique'])
+  })
+
+  it('marks public.eql_v3_boolean as storage-only (no indexes, all capabilities false)', () => {
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_boolean@1')
+    expect(meta?.nativeType).toBe('public.eql_v3_boolean')
+    expect(meta?.castAs).toBe('boolean')
+    expect(meta?.capabilities).toEqual({ equality: false, orderAndRange: false, freeTextSearch: false })
+    expect(Object.keys(meta?.indexes ?? {})).toEqual([])
+  })
+
+  it('exposes bigint as a first-class family with bigint castAs', () => {
+    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint@1')?.castAs).toBe('bigint')
+    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint_ord@1')?.nativeType).toBe(
+      'public.eql_v3_bigint_ord',
+    )
+  })
+
+  it('derives timestamp castAs distinctly from date', () => {
+    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_timestamp@1')?.castAs).toBe('timestamp')
+    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_date@1')?.castAs).toBe('date')
+  })
+
+  it('exposes json as a first-class searchable-JSON domain (ste_vec index)', () => {
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_json@1')
+    expect(meta?.nativeType).toBe('public.eql_v3_json')
+    expect(meta?.castAs).toBe('json')
+    expect(meta?.capabilities).toEqual({
+      equality: false,
+      orderAndRange: false,
+      freeTextSearch: false,
+      searchableJson: true,
+    })
+    expect(Object.keys(meta?.indexes ?? {})).toEqual(['ste_vec'])
+    expect(EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json')).toBe(true)
+  })
+
+  it('maps native type back to its concrete factory', () => {
+    const factory = V3_FACTORY_BY_NATIVE_TYPE.get('public.eql_v3_integer_ord')
+    expect(factory).toBeDefined()
+    expect(factory?.('score').getEqlType()).toBe('public.eql_v3_integer_ord')
+  })
+
+  it('maps castAs to the envelope type name (bigint distinct from number, json distinct)', () => {
+    expect(envelopeTypeNameForCastAs('string')).toBe('EncryptedString')
+    expect(envelopeTypeNameForCastAs('number')).toBe('EncryptedNumber')
+    expect(envelopeTypeNameForCastAs('bigint')).toBe('EncryptedBigInt')
+    expect(envelopeTypeNameForCastAs('date')).toBe('EncryptedDate')
+    expect(envelopeTypeNameForCastAs('timestamp')).toBe('EncryptedDate')
+    expect(envelopeTypeNameForCastAs('boolean')).toBe('EncryptedBoolean')
+    expect(envelopeTypeNameForCastAs('json')).toBe('EncryptedJson')
+  })
+
+  it('includes *_ord_ore in the full meta but excludes it from the exposed entries', () => {
+    expect(V3_DOMAIN_META_BY_CODEC_ID.has('cipherstash/eql-v3/eql_v3_integer_ord_ore@1')).toBe(true)
+    expect(isOrdOreDomain('eql_v3_integer_ord_ore')).toBe(true)
+    const exposedBare = new Set(EXPOSED_DOMAIN_ENTRIES.map(([, m]) => m.bareDomain))
+    expect([...exposedBare].some((b) => b.endsWith('_ord_ore'))).toBe(false)
+    expect(exposedBare.has('eql_v3_integer_ord')).toBe(true)
+    expect(exposedBare.has('eql_v3_bigint')).toBe(true)
+  })
+
+  it('every codec id is v3-namespaced and unique', () => {
+    expect(new Set(V3_CODEC_IDS).size).toBe(V3_CODEC_IDS.length)
+    for (const id of V3_CODEC_IDS) expect(id.startsWith('cipherstash/eql-v3/')).toBe(true)
+  })
+})
diff --git a/packages/stack/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts
index 62013292..b46b43c1 100644
--- a/packages/stack/src/eql/v3/index.ts
+++ b/packages/stack/src/eql/v3/index.ts
@@ -62,6 +62,12 @@ export {
   EncryptedTimestampOrdOreColumn,
   TEXT_SEARCH_EQL_TYPE,
 } from './columns'
+export {
+  DOMAIN_REGISTRY,
+  factoryForDomain,
+  stripDomainSchema,
+  type V3ColumnFactory,
+} from './domain-registry'
 export type {
   AnyV3Table,
   ColumnsOf,

From 1b1afb024bd57ad55e0192432ac829bf061f8553 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 12:39:10 -0600
Subject: [PATCH 02/21] feat(prisma-next): v3 codec-id closed union, traits,
 invariants, drift test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The closed union infers eqlType from getEqlType()'s return type — the
stack's bundled d.ts drops the private definition field's type, so the
EqlTypeForColumn infer-D path widens to public.${string} downstream.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/extension-metadata/constants-v3.ts    | 140 ++++++++++++++++++
 .../test/v3/catalog-invariants.test.ts        |  55 +++++++
 .../prisma-next/test/v3/constants-v3.test.ts  |  68 +++++++++
 3 files changed, 263 insertions(+)
 create mode 100644 packages/prisma-next/src/extension-metadata/constants-v3.ts
 create mode 100644 packages/prisma-next/test/v3/catalog-invariants.test.ts
 create mode 100644 packages/prisma-next/test/v3/constants-v3.test.ts

diff --git a/packages/prisma-next/src/extension-metadata/constants-v3.ts b/packages/prisma-next/src/extension-metadata/constants-v3.ts
new file mode 100644
index 00000000..30307612
--- /dev/null
+++ b/packages/prisma-next/src/extension-metadata/constants-v3.ts
@@ -0,0 +1,140 @@
+/**
+ * v3 codec ids, traits, and migration invariants. Parallel to the v2
+ * `constants.ts`; imports NO v2 codec/wire code. Codec ids are the generated
+ * closed union derived from the imported catalog: `(codec id) ⟺ (public.*
+ * domain)` is bijective, so the id set IS the catalog.
+ */
+import type { AnyEncryptedV3Column, QueryCapabilities } from '@cipherstash/stack/eql/v3'
+import {
+  CIPHERSTASH_TRAIT_EQUALITY,
+  CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+  CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+  CIPHERSTASH_TRAIT_SEARCHABLE_JSON,
+} from './constants'
+
+export {
+  CIPHERSTASH_TRAIT_EQUALITY,
+  CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+  CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+  CIPHERSTASH_TRAIT_SEARCHABLE_JSON,
+}
+
+/** Strip the `public.` schema qualifier at the type level. */
+type StripSchema<T> = T extends `public.${infer D}` ? D : never
+
+/**
+ * Per-column literal `eqlType`, inferred from the `getEqlType()` return type
+ * rather than the stack's `EqlTypeForColumn<C>`. NOT a style choice: the
+ * stack's bundled `.d.ts` emits the base class's private `definition` field
+ * without its type, so `C extends EncryptedV3Column<infer D>` (which
+ * `EqlTypeForColumn` uses) has nothing to infer `D` from and falls back to the
+ * constraint — widening every id to `` `public.${string}` `` and silently
+ * disabling the closed-union drift guards below. The getter's declared return
+ * type survives d.ts bundling because each concrete subclass binds `D`
+ * explicitly in its `extends` clause.
+ */
+type EqlTypeFromGetter<C> = C extends { getEqlType(): infer T } ? T : never
+
+/** Compile-time closed union: one concrete codec id per catalog domain. A
+ * catalog change that adds/drops a domain surfaces as a type error at the
+ * `satisfies` line below. The domain segment is the GA registry key VERBATIM
+ * (`eql_v3_*`); the leading `eql-v3` path token is the logical version tag. */
+export type CipherstashV3CodecId =
+  `cipherstash/eql-v3/${StripSchema<EqlTypeFromGetter<AnyEncryptedV3Column>>}@1`
+
+/**
+ * PINNED literal tuple — the compile-time source of truth for the v3 codec-id
+ * set. Hand-listed, one entry per catalog domain (INCLUDING the `*_ord_ore`
+ * variants that authoring does not expose but the codec/derivation layer still
+ * decodes). This is deliberately NOT `V3_CODEC_IDS as readonly CipherstashV3CodecId[]`
+ * — that is a masking cast that asserts the derived array IS the union and so
+ * catches NO drift. Here, catalog drift fails to COMPILE in both directions:
+ *   - `satisfies readonly CipherstashV3CodecId[]` fails if a listed id is no
+ *     longer a catalog domain (a domain removed / renamed).
+ *   - `_NoUnpinnedDomain` (below) fails if the catalog gained a domain not
+ *     pinned here.
+ * The runtime drift test additionally asserts this equals the registry-derived
+ * `V3_CODEC_IDS` (guarding the derivation itself).
+ */
+export const CIPHERSTASH_V3_CODEC_IDS = [
+  'cipherstash/eql-v3/eql_v3_integer@1',
+  'cipherstash/eql-v3/eql_v3_integer_eq@1',
+  'cipherstash/eql-v3/eql_v3_integer_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_integer_ord@1',
+  'cipherstash/eql-v3/eql_v3_smallint@1',
+  'cipherstash/eql-v3/eql_v3_smallint_eq@1',
+  'cipherstash/eql-v3/eql_v3_smallint_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_smallint_ord@1',
+  'cipherstash/eql-v3/eql_v3_bigint@1',
+  'cipherstash/eql-v3/eql_v3_bigint_eq@1',
+  'cipherstash/eql-v3/eql_v3_bigint_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_bigint_ord@1',
+  'cipherstash/eql-v3/eql_v3_date@1',
+  'cipherstash/eql-v3/eql_v3_date_eq@1',
+  'cipherstash/eql-v3/eql_v3_date_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_date_ord@1',
+  'cipherstash/eql-v3/eql_v3_timestamp@1',
+  'cipherstash/eql-v3/eql_v3_timestamp_eq@1',
+  'cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_timestamp_ord@1',
+  'cipherstash/eql-v3/eql_v3_numeric@1',
+  'cipherstash/eql-v3/eql_v3_numeric_eq@1',
+  'cipherstash/eql-v3/eql_v3_numeric_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_numeric_ord@1',
+  'cipherstash/eql-v3/eql_v3_text@1',
+  'cipherstash/eql-v3/eql_v3_text_eq@1',
+  'cipherstash/eql-v3/eql_v3_text_match@1',
+  'cipherstash/eql-v3/eql_v3_text_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_text_ord@1',
+  'cipherstash/eql-v3/eql_v3_text_search@1',
+  'cipherstash/eql-v3/eql_v3_boolean@1',
+  'cipherstash/eql-v3/eql_v3_real@1',
+  'cipherstash/eql-v3/eql_v3_real_eq@1',
+  'cipherstash/eql-v3/eql_v3_real_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_real_ord@1',
+  'cipherstash/eql-v3/eql_v3_double@1',
+  'cipherstash/eql-v3/eql_v3_double_eq@1',
+  'cipherstash/eql-v3/eql_v3_double_ord_ore@1',
+  'cipherstash/eql-v3/eql_v3_double_ord@1',
+  'cipherstash/eql-v3/eql_v3_json@1',
+] as const satisfies readonly CipherstashV3CodecId[]
+
+// Bidirectional drift guard — the direction `satisfies` cannot catch. If the
+// catalog gains a domain that is not pinned above, `Exclude<...>` is non-`never`
+// and this assignment fails to compile with the offending id in the error.
+type _PinnedId = (typeof CIPHERSTASH_V3_CODEC_IDS)[number]
+type _NoUnpinnedDomain = [Exclude<CipherstashV3CodecId, _PinnedId>] extends [never]
+  ? true
+  : ['catalog gained an unpinned codec id', Exclude<CipherstashV3CodecId, _PinnedId>]
+const _driftGuard: _NoUnpinnedDomain = true
+void _driftGuard
+
+export const CIPHERSTASH_V3_CODEC_ID_SET: ReadonlySet<string> = new Set(CIPHERSTASH_V3_CODEC_IDS)
+
+export function isCipherstashV3CodecId(id: string): id is CipherstashV3CodecId {
+  return CIPHERSTASH_V3_CODEC_ID_SET.has(id)
+}
+
+export function v3TraitsForCapabilities(caps: QueryCapabilities): readonly string[] {
+  const traits: string[] = []
+  if (caps.equality) traits.push(CIPHERSTASH_TRAIT_EQUALITY)
+  if (caps.orderAndRange) traits.push(CIPHERSTASH_TRAIT_ORDER_AND_RANGE)
+  if (caps.freeTextSearch) traits.push(CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH)
+  if (caps.searchableJson) traits.push(CIPHERSTASH_TRAIT_SEARCHABLE_JSON)
+  return traits
+}
+
+export const CIPHERSTASH_V3_BASELINE_MIGRATION_NAME = '20260601T0100_install_eql_v3_bundle'
+
+export const CIPHERSTASH_V3_INVARIANTS = {
+  installBundle: 'cipherstash:install-eql-v3-bundle-v1',
+} as const
+
+// v3's OWN extension identity (decision 1b) — DISTINCT from the v2
+// CIPHERSTASH_SPACE_ID / CIPHERSTASH_EXTENSION_VERSION. v2 and v3 are separate
+// entry points, never co-registered in one client; the distinct id keeps the
+// two extension descriptors cleanly separate. The shape mirrors the v2 id
+// (a bare, path-safe token — it may be used as a directory segment) rather
+// than a slashed namespace.
+export const CIPHERSTASH_V3_SPACE_ID = 'cipherstash-eql-v3' as const
+export const CIPHERSTASH_V3_EXTENSION_VERSION = '1.0.0' as const
diff --git a/packages/prisma-next/test/v3/catalog-invariants.test.ts b/packages/prisma-next/test/v3/catalog-invariants.test.ts
new file mode 100644
index 00000000..efa62318
--- /dev/null
+++ b/packages/prisma-next/test/v3/catalog-invariants.test.ts
@@ -0,0 +1,55 @@
+import { DOMAIN_REGISTRY } from '@cipherstash/stack/eql/v3'
+import { describe, expect, it } from 'vitest'
+import { EXPOSED_DOMAIN_ENTRIES, V3_DOMAIN_META_BY_CODEC_ID } from '../../src/v3/catalog'
+
+describe('FFI catalog invariants (non-structural — pinned)', () => {
+  const bareDomains = Object.keys(DOMAIN_REGISTRY)
+
+  it('exposes json as a first-class searchable-JSON domain (ste_vec, no scalar caps)', () => {
+    expect(bareDomains.filter((d) => d.includes('json'))).toEqual(['eql_v3_json'])
+    const json = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_json@1')
+    expect(json?.nativeType).toBe('public.eql_v3_json')
+    expect(json?.capabilities.searchableJson).toBe(true)
+    expect(json?.capabilities.equality).toBe(false)
+    expect(Object.keys(json?.indexes ?? {})).toEqual(['ste_vec'])
+    expect(EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json')).toBe(true)
+  })
+
+  it('public.eql_v3_boolean is storage-only (advertises no equality, no indexes)', () => {
+    const bool = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_boolean@1')
+    expect(bool?.nativeType).toBe('public.eql_v3_boolean')
+    expect(bool?.capabilities.equality).toBe(false)
+    expect(Object.keys(bool?.indexes ?? {})).toEqual([])
+    // there is only one boolean domain (no boolean_eq)
+    expect(bareDomains.filter((d) => d.startsWith('eql_v3_boolean'))).toEqual(['eql_v3_boolean'])
+  })
+
+  it('the BigInt family IS exposed (base/_eq/_ord), *OrdOre is not', () => {
+    const exposedBare = EXPOSED_DOMAIN_ENTRIES.map(([, m]) => m.bareDomain)
+    expect(exposedBare).toEqual(
+      expect.arrayContaining(['eql_v3_bigint', 'eql_v3_bigint_eq', 'eql_v3_bigint_ord']),
+    )
+    expect(exposedBare).not.toContain('eql_v3_bigint_ord_ore')
+    expect(exposedBare.some((b) => b.endsWith('_ord_ore'))).toBe(false)
+  })
+
+  it('plain _ord domains and text_search are OPE-backed; only _ord_ore keeps block-ORE', () => {
+    for (const [, meta] of V3_DOMAIN_META_BY_CODEC_ID) {
+      const indexKeys = Object.keys(meta.indexes)
+      if (meta.bareDomain.endsWith('_ord_ore')) {
+        expect(indexKeys).toContain('ore')
+        expect(indexKeys).not.toContain('ope')
+      } else if (meta.bareDomain.endsWith('_ord') || meta.bareDomain === 'eql_v3_text_search') {
+        expect(indexKeys).toContain('ope')
+        expect(indexKeys).not.toContain('ore')
+      }
+    }
+  })
+
+  it('native types are public.* while operator SQL is eql_v3.* (schema split not collapsed)', () => {
+    for (const [, meta] of V3_DOMAIN_META_BY_CODEC_ID) {
+      expect(meta.nativeType.startsWith('public.')).toBe(true)
+      expect(meta.nativeType.startsWith('eql_v3.')).toBe(false)
+    }
+  })
+})
diff --git a/packages/prisma-next/test/v3/constants-v3.test.ts b/packages/prisma-next/test/v3/constants-v3.test.ts
new file mode 100644
index 00000000..720b0d38
--- /dev/null
+++ b/packages/prisma-next/test/v3/constants-v3.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import {
+  CIPHERSTASH_CODEC_IDS,
+  CIPHERSTASH_EXTENSION_VERSION,
+  CIPHERSTASH_SPACE_ID,
+} from '../../src/extension-metadata/constants'
+import {
+  CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+  CIPHERSTASH_V3_CODEC_ID_SET,
+  CIPHERSTASH_V3_CODEC_IDS,
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_INVARIANTS,
+  CIPHERSTASH_V3_SPACE_ID,
+  isCipherstashV3CodecId,
+  v3TraitsForCapabilities,
+} from '../../src/extension-metadata/constants-v3'
+import { V3_CODEC_IDS } from '../../src/v3/catalog'
+
+describe('constants-v3', () => {
+  it('the PINNED codec-id tuple equals the registry-derived set (drift guard, runtime side)', () => {
+    // The compile-time `satisfies` + `Exclude` guards catch type drift; this
+    // catches derivation drift (e.g. the registry iteration silently dropping
+    // or reordering a domain). Both directions must hold.
+    expect(new Set(CIPHERSTASH_V3_CODEC_IDS)).toEqual(new Set(V3_CODEC_IDS))
+    expect(CIPHERSTASH_V3_CODEC_IDS.length).toBe(V3_CODEC_IDS.length)
+    expect(new Set(CIPHERSTASH_V3_CODEC_IDS).size).toBe(CIPHERSTASH_V3_CODEC_IDS.length)
+  })
+
+  it('v3 and v2 codec-id sets are disjoint', () => {
+    const v2 = new Set<string>(CIPHERSTASH_CODEC_IDS)
+    for (const id of CIPHERSTASH_V3_CODEC_IDS) expect(v2.has(id)).toBe(false)
+  })
+
+  it('guard narrows only v3 ids', () => {
+    expect(isCipherstashV3CodecId('cipherstash/eql-v3/eql_v3_text_eq@1')).toBe(true)
+    expect(isCipherstashV3CodecId('cipherstash/string@1')).toBe(false)
+    // GA registry keys are eql_v3_*-prefixed; the un-prefixed form is NOT an id.
+    expect(isCipherstashV3CodecId('cipherstash/eql-v3/text_eq@1')).toBe(false)
+    expect(CIPHERSTASH_V3_CODEC_ID_SET.has('cipherstash/eql-v3/eql_v3_text_eq@1')).toBe(true)
+  })
+
+  it('derives cipherstash-namespaced traits from capabilities', () => {
+    expect(
+      [...v3TraitsForCapabilities({ equality: true, orderAndRange: true, freeTextSearch: true })].sort(),
+    ).toEqual(['cipherstash:equality', 'cipherstash:free-text-search', 'cipherstash:order-and-range'])
+    expect(
+      v3TraitsForCapabilities({ equality: false, orderAndRange: false, freeTextSearch: false }),
+    ).toEqual([])
+    expect(
+      v3TraitsForCapabilities({
+        equality: false,
+        orderAndRange: false,
+        freeTextSearch: false,
+        searchableJson: true,
+      }),
+    ).toEqual(['cipherstash:searchable-json'])
+  })
+
+  it('pins the migration name + invariant', () => {
+    expect(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).toBe('20260601T0100_install_eql_v3_bundle')
+    expect(CIPHERSTASH_V3_INVARIANTS.installBundle).toBe('cipherstash:install-eql-v3-bundle-v1')
+  })
+
+  it('v3 extension identity is distinct from v2 (decision 1b — separate entry points)', () => {
+    expect(CIPHERSTASH_V3_SPACE_ID).not.toBe(CIPHERSTASH_SPACE_ID)
+    expect(CIPHERSTASH_V3_EXTENSION_VERSION).not.toBe(CIPHERSTASH_EXTENSION_VERSION)
+  })
+})

From 0161834587045dd7fa0ff212b170a93607fd7713 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 12:54:01 -0600
Subject: [PATCH 03/21] feat(prisma-next): v3 per-domain authoring constructors
 + *V2 aliases

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../prisma-next/src/contract-authoring.ts     | 542 +++++++++++-------
 .../prisma-next/src/exports/column-types.ts   | 209 +++++--
 .../src/extension-metadata/constants-v3.ts    |  25 +-
 packages/prisma-next/src/v3/catalog.ts        |  17 +-
 packages/prisma-next/test/authoring.test.ts   | 238 +++++---
 .../prisma-next/test/column-types.test.ts     | 163 ++++--
 .../test/psl-interpretation-numeric.test.ts   |  20 +-
 .../psl-interpretation-other-types.test.ts    |  28 +-
 .../test/psl-interpretation.test.ts           | 131 ++++-
 .../test/v3/catalog-invariants.test.ts        |  36 +-
 packages/prisma-next/test/v3/catalog.test.ts  |  77 ++-
 .../test/v3/column-types.test-d.ts            |  45 ++
 .../prisma-next/test/v3/constants-v3.test.ts  |  44 +-
 13 files changed, 1140 insertions(+), 435 deletions(-)
 create mode 100644 packages/prisma-next/test/v3/column-types.test-d.ts

diff --git a/packages/prisma-next/src/contract-authoring.ts b/packages/prisma-next/src/contract-authoring.ts
index 1e27ba0f..6312ad2a 100644
--- a/packages/prisma-next/src/contract-authoring.ts
+++ b/packages/prisma-next/src/contract-authoring.ts
@@ -1,29 +1,52 @@
 /**
  * Authoring contributions for the cipherstash extension.
  *
- * Registers `cipherstash.EncryptedString({ equality?, freeTextSearch? })`
- * as a namespaced PSL type constructor. The same descriptor lowers a
- * PSL field-type expression like `cipherstash.EncryptedString({ equality:
- * true })` and a TS factory call like `encryptedString({ equality: true })`
- * (see `../exports/column-types`) to an identical `ColumnTypeDescriptor`
- * so PSL- and TS-authored contracts emit byte-identical `contract.json`.
+ * ## v3: one concrete constructor per exposed domain
  *
- * Mirrors `packages/3-extensions/pgvector/src/core/authoring.ts`. The
- * cipherstash variant differs in three respects:
- *   (a) `cipherstash` is the namespace,
- *   (b) the constructor takes a single OPTIONAL object argument with two
- *       optional booleans (so `cipherstash.EncryptedString()`,
- *       `cipherstash.EncryptedString({})`, and the fully-spelled
- *       `cipherstash.EncryptedString({ equality: true, freeTextSearch: true })`
- *       all parse), and
- *   (c) both flags default to `true` — searchable encryption is the
- *       legitimate default for an extension whose entire reason for
- *       existing is to make encrypted columns queryable. Users who want
- *       storage-only encryption opt out explicitly:
- *       `cipherstash.EncryptedString({ equality: false, freeTextSearch: false })`.
+ * Every exposed v3 domain (the catalog minus the authoring-unexposed
+ * `*_ord_ore` variants) gets exactly one argument-less PSL constructor,
+ * derived 1:1 from `EXPOSED_DOMAIN_ENTRIES`:
+ *
+ *   `cipherstash.EncryptedTextSearch` → codec
+ *   `cipherstash/eql-v3/eql_v3_text_search@1`, native type
+ *   `public.eql_v3_text_search`, static
+ *   `typeParams: { castAs, capabilities }`.
+ *
+ * There are NO options: the constructor IS the capability set. The name is
+ * the mechanical `Encrypted<Stem><Suffix>` transform of the bare domain with
+ * its `eql_v3_` prefix stripped (`eql_v3_bigint_ord` → `EncryptedBigIntOrd`);
+ * the codec id keeps the registry key VERBATIM (never name-transformed).
+ *
+ * ### Static typeParams — confirmed framework shape (Step 0)
+ *
+ * `AuthoringStorageTypeTemplate.typeParams` is
+ * `Record<string, AuthoringTemplateValue>`, and `AuthoringTemplateValue`
+ * admits plain literals, arrays, and nested plain objects alongside
+ * `AuthoringArgRef` nodes (framework-components 0.14,
+ * `framework-authoring.d.ts`). `resolveAuthoringTemplateValue` deep-walks
+ * objects and passes every non-`{ kind: 'arg' }` leaf through verbatim, so
+ * the static `{ castAs, capabilities }` block below lowers to itself — no
+ * `{ kind: 'literal' }` wrapper exists or is needed.
+ *
+ * ## v2: legacy `*V2` aliases
+ *
+ * The six pre-existing v2 constructors survive verbatim under `*V2` names
+ * (`EncryptedStringV2`, …): same optional-object argument (all search-mode
+ * flags default to `true` — searchable encryption is the legitimate default;
+ * users opt out explicitly), same `cipherstash/*@1` codec ids, same
+ * `eql_v2_encrypted` native type.
+ *
+ * The same descriptors lower a PSL field-type expression and the matching TS
+ * factory (see `./exports/column-types`) to an identical
+ * `ColumnTypeDescriptor`, so PSL- and TS-authored contracts emit
+ * byte-identical `contract.json`.
  */
 
-import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring'
+import type { QueryCapabilities } from '@cipherstash/stack/eql/v3'
+import type {
+  AuthoringTypeConstructorDescriptor,
+  AuthoringTypeNamespace,
+} from '@prisma-next/framework-components/authoring'
 import {
   CIPHERSTASH_BIGINT_CODEC_ID,
   CIPHERSTASH_BOOLEAN_CODEC_ID,
@@ -33,193 +56,320 @@ import {
   CIPHERSTASH_STRING_CODEC_ID,
   EQL_V2_ENCRYPTED_TYPE,
 } from './extension-metadata/constants'
+import { EXPOSED_DOMAIN_ENTRIES, type V3DomainMeta } from './v3/catalog'
 
-export const cipherstashAuthoringTypes = {
-  cipherstash: {
-    EncryptedString: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            equality: { kind: 'boolean', optional: true },
-            freeTextSearch: { kind: 'boolean', optional: true },
-            orderAndRange: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_STRING_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          equality: {
-            kind: 'arg',
-            index: 0,
-            path: ['equality'],
-            default: true,
-          },
-          freeTextSearch: {
-            kind: 'arg',
-            index: 0,
-            path: ['freeTextSearch'],
-            default: true,
-          },
-          orderAndRange: {
-            kind: 'arg',
-            index: 0,
-            path: ['orderAndRange'],
-            default: true,
-          },
-        },
+// The stem of a bare domain maps to a JS-friendly display label; the suffix
+// after the first `_` names the capability tier. `bigint` deliberately renders
+// as `BigInt` (capital I) while `smallint` stays `Smallint` — this table is the
+// single source for both PSL (`Encrypted…`) and TS (`encrypted…`) names.
+const STEM_LABEL: Record<string, string> = {
+  text: 'Text',
+  integer: 'Integer',
+  smallint: 'Smallint',
+  bigint: 'BigInt',
+  numeric: 'Numeric',
+  real: 'Real',
+  double: 'Double',
+  date: 'Date',
+  timestamp: 'Timestamp',
+  boolean: 'Boolean',
+  json: 'Json',
+}
+const SUFFIX_LABEL: Record<string, string> = {
+  '': '',
+  eq: 'Eq',
+  ord: 'Ord',
+  match: 'Match',
+  search: 'Search',
+}
+
+const EQL_V3_DOMAIN_PREFIX = 'eql_v3_'
+
+function coreName(bareDomain: string): string {
+  // Every GA domain is `eql_v3_`-prefixed; a bare domain without it means the
+  // registry drifted under us — fail loudly rather than emit a wrong name.
+  if (!bareDomain.startsWith(EQL_V3_DOMAIN_PREFIX)) {
+    throw new Error(
+      `contract-authoring: exposed domain "${bareDomain}" lacks the "${EQL_V3_DOMAIN_PREFIX}" prefix — registry drift.`,
+    )
+  }
+  const core = bareDomain.slice(EQL_V3_DOMAIN_PREFIX.length)
+  const i = core.indexOf('_')
+  const stem = i === -1 ? core : core.slice(0, i)
+  const suffix = i === -1 ? '' : core.slice(i + 1)
+  const stemLabel = STEM_LABEL[stem]
+  const suffixLabel = SUFFIX_LABEL[suffix]
+  if (stemLabel === undefined || suffixLabel === undefined) {
+    throw new Error(
+      `contract-authoring: cannot name exposed domain "${bareDomain}" — extend STEM_LABEL/SUFFIX_LABEL.`,
+    )
+  }
+  return `${stemLabel}${suffixLabel}`
+}
+
+/** `eql_v3_text_search` → `EncryptedTextSearch`, `eql_v3_bigint_ord` → `EncryptedBigIntOrd`. */
+export function v3PascalName(bareDomain: string): string {
+  return `Encrypted${coreName(bareDomain)}`
+}
+/** `eql_v3_text_search` → `encryptedTextSearch`, `eql_v3_bigint_ord` → `encryptedBigIntOrd`. */
+export function v3CamelName(bareDomain: string): string {
+  return `encrypted${coreName(bareDomain)}`
+}
+
+/**
+ * Re-shape the catalog's `QueryCapabilities` as an `AuthoringTemplateValue`
+ * object. Explicit construction (rather than passing the catalog object
+ * through) keeps the optional `searchableJson` slot out of the template when
+ * the domain doesn't carry it, so non-JSON domains lower to exactly the three
+ * boolean flags.
+ */
+function capabilitiesTemplate(
+  capabilities: QueryCapabilities,
+): Record<string, boolean> {
+  return {
+    equality: capabilities.equality,
+    orderAndRange: capabilities.orderAndRange,
+    freeTextSearch: capabilities.freeTextSearch,
+    ...(capabilities.searchableJson !== undefined
+      ? { searchableJson: capabilities.searchableJson }
+      : {}),
+  }
+}
+
+function v3Constructor(
+  codecId: string,
+  meta: V3DomainMeta,
+): AuthoringTypeConstructorDescriptor {
+  return {
+    kind: 'typeConstructor',
+    args: [],
+    output: {
+      codecId,
+      nativeType: meta.nativeType,
+      // Static, not `{ kind: 'arg' }`: there are no options — the constructor
+      // IS the capability set (see "Static typeParams" in the header).
+      typeParams: {
+        castAs: meta.castAs,
+        capabilities: capabilitiesTemplate(meta.capabilities),
+      },
+    },
+  }
+}
+
+// --- v2 legacy aliases (verbatim pre-rename v2 outputs, now keyed *V2) ---
+
+const encryptedStringV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        equality: { kind: 'boolean', optional: true },
+        freeTextSearch: { kind: 'boolean', optional: true },
+        orderAndRange: { kind: 'boolean', optional: true },
+      },
+    },
+  ],
+  output: {
+    codecId: CIPHERSTASH_STRING_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      equality: {
+        kind: 'arg',
+        index: 0,
+        path: ['equality'],
+        default: true,
+      },
+      freeTextSearch: {
+        kind: 'arg',
+        index: 0,
+        path: ['freeTextSearch'],
+        default: true,
+      },
+      orderAndRange: {
+        kind: 'arg',
+        index: 0,
+        path: ['orderAndRange'],
+        default: true,
+      },
+    },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const encryptedDoubleV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        equality: { kind: 'boolean', optional: true },
+        orderAndRange: { kind: 'boolean', optional: true },
       },
     },
-    EncryptedDouble: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            equality: { kind: 'boolean', optional: true },
-            orderAndRange: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_DOUBLE_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          equality: {
-            kind: 'arg',
-            index: 0,
-            path: ['equality'],
-            default: true,
-          },
-          orderAndRange: {
-            kind: 'arg',
-            index: 0,
-            path: ['orderAndRange'],
-            default: true,
-          },
-        },
+  ],
+  output: {
+    codecId: CIPHERSTASH_DOUBLE_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      equality: {
+        kind: 'arg',
+        index: 0,
+        path: ['equality'],
+        default: true,
+      },
+      orderAndRange: {
+        kind: 'arg',
+        index: 0,
+        path: ['orderAndRange'],
+        default: true,
       },
     },
-    EncryptedBigInt: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            equality: { kind: 'boolean', optional: true },
-            orderAndRange: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_BIGINT_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          equality: {
-            kind: 'arg',
-            index: 0,
-            path: ['equality'],
-            default: true,
-          },
-          orderAndRange: {
-            kind: 'arg',
-            index: 0,
-            path: ['orderAndRange'],
-            default: true,
-          },
-        },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const encryptedBigIntV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        equality: { kind: 'boolean', optional: true },
+        orderAndRange: { kind: 'boolean', optional: true },
       },
     },
-    EncryptedDate: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            equality: { kind: 'boolean', optional: true },
-            orderAndRange: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_DATE_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          equality: {
-            kind: 'arg',
-            index: 0,
-            path: ['equality'],
-            default: true,
-          },
-          orderAndRange: {
-            kind: 'arg',
-            index: 0,
-            path: ['orderAndRange'],
-            default: true,
-          },
-        },
+  ],
+  output: {
+    codecId: CIPHERSTASH_BIGINT_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      equality: {
+        kind: 'arg',
+        index: 0,
+        path: ['equality'],
+        default: true,
+      },
+      orderAndRange: {
+        kind: 'arg',
+        index: 0,
+        path: ['orderAndRange'],
+        default: true,
       },
     },
-    EncryptedBoolean: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            equality: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_BOOLEAN_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          equality: {
-            kind: 'arg',
-            index: 0,
-            path: ['equality'],
-            default: true,
-          },
-        },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const encryptedDateV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        equality: { kind: 'boolean', optional: true },
+        orderAndRange: { kind: 'boolean', optional: true },
+      },
+    },
+  ],
+  output: {
+    codecId: CIPHERSTASH_DATE_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      equality: {
+        kind: 'arg',
+        index: 0,
+        path: ['equality'],
+        default: true,
+      },
+      orderAndRange: {
+        kind: 'arg',
+        index: 0,
+        path: ['orderAndRange'],
+        default: true,
       },
     },
-    EncryptedJson: {
-      kind: 'typeConstructor',
-      args: [
-        {
-          kind: 'object',
-          name: 'options',
-          optional: true,
-          properties: {
-            searchableJson: { kind: 'boolean', optional: true },
-          },
-        },
-      ],
-      output: {
-        codecId: CIPHERSTASH_JSON_CODEC_ID,
-        nativeType: EQL_V2_ENCRYPTED_TYPE,
-        typeParams: {
-          searchableJson: {
-            kind: 'arg',
-            index: 0,
-            path: ['searchableJson'],
-            default: true,
-          },
-        },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const encryptedBooleanV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        equality: { kind: 'boolean', optional: true },
       },
     },
+  ],
+  output: {
+    codecId: CIPHERSTASH_BOOLEAN_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      equality: {
+        kind: 'arg',
+        index: 0,
+        path: ['equality'],
+        default: true,
+      },
+    },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const encryptedJsonV2 = {
+  kind: 'typeConstructor',
+  args: [
+    {
+      kind: 'object',
+      name: 'options',
+      optional: true,
+      properties: {
+        searchableJson: { kind: 'boolean', optional: true },
+      },
+    },
+  ],
+  output: {
+    codecId: CIPHERSTASH_JSON_CODEC_ID,
+    nativeType: EQL_V2_ENCRYPTED_TYPE,
+    typeParams: {
+      searchableJson: {
+        kind: 'arg',
+        index: 0,
+        path: ['searchableJson'],
+        default: true,
+      },
+    },
+  },
+} as const satisfies AuthoringTypeConstructorDescriptor
+
+const v3Constructors: Record<string, AuthoringTypeConstructorDescriptor> =
+  Object.fromEntries(
+    EXPOSED_DOMAIN_ENTRIES.map(
+      ([codecId, meta]) =>
+        [v3PascalName(meta.bareDomain), v3Constructor(codecId, meta)] as const,
+    ),
+  )
+
+// Dynamic construction loses the literal object type the old
+// `as const satisfies` gave this file; the explicit `AuthoringTypeNamespace`
+// annotation keeps the shape checked, and the 1:1 test in
+// `test/authoring.test.ts` enforces the derived constructor set at runtime.
+export const cipherstashAuthoringTypes: AuthoringTypeNamespace = {
+  cipherstash: {
+    ...v3Constructors,
+    // v2 legacy aliases
+    EncryptedStringV2: encryptedStringV2,
+    EncryptedDoubleV2: encryptedDoubleV2,
+    EncryptedBigIntV2: encryptedBigIntV2,
+    EncryptedDateV2: encryptedDateV2,
+    EncryptedBooleanV2: encryptedBooleanV2,
+    EncryptedJsonV2: encryptedJsonV2,
   },
-} as const satisfies AuthoringTypeNamespace
+}
diff --git a/packages/prisma-next/src/exports/column-types.ts b/packages/prisma-next/src/exports/column-types.ts
index 27ffc0f5..f97bc49c 100644
--- a/packages/prisma-next/src/exports/column-types.ts
+++ b/packages/prisma-next/src/exports/column-types.ts
@@ -1,24 +1,35 @@
 /**
  * TS contract factories for cipherstash-encrypted columns.
  *
- * Counterparts to the PSL constructors `cipherstash.Encrypted<Type>({...})`
- * registered in `../contract-authoring`. The six factories
- * (`encryptedString`, `encryptedDouble`, `encryptedBigInt`,
- * `encryptedDate`, `encryptedBoolean`, `encryptedJson`) produce the
- * same `ColumnTypeDescriptor` shape as their PSL counterparts, so
- * PSL- and TS-authored contracts emit byte-identical `contract.json`.
- * Pinned by the parity fixtures at
- * `test/integration/test/authoring/parity/cipherstash-encrypted-{string,double,bigint,date,boolean,json}/`.
+ * ## v3: one factory per exposed domain
  *
- * Every search-mode flag defaults to `true` — searchable encryption
- * is the legitimate default for an extension whose entire reason for
- * existing is to make encrypted columns queryable. Users who want
- * storage-only encryption opt out explicitly:
- * `encryptedString({ equality: false, freeTextSearch: false, orderAndRange: false })`.
- * Mirrors the PSL constructors' `true` defaults declared via
+ * Counterparts to the argument-less PSL constructors
+ * `cipherstash.Encrypted<Stem><Suffix>()` registered in
+ * `../contract-authoring`. Each factory returns the domain's concrete
+ * descriptor — static codec id, `public.eql_v3_*` native type, and a static
+ * `{ castAs, capabilities }` typeParams block — identical to what its PSL
+ * counterpart lowers to, so PSL- and TS-authored contracts emit
+ * byte-identical `contract.json`. There are NO options: the factory IS the
+ * capability set (`encryptedTextSearch` vs `encryptedText`, and so on).
+ *
+ * ## v2: legacy `*V2` aliases
+ *
+ * The six pre-rename factories (`encryptedStringV2`, `encryptedDoubleV2`,
+ * `encryptedBigIntV2`, `encryptedDateV2`, `encryptedBooleanV2`,
+ * `encryptedJsonV2`) keep their previous bodies verbatim: single optional
+ * options object, every search-mode flag defaulting to `true` — searchable
+ * encryption is the legitimate default for an extension whose entire reason
+ * for existing is to make encrypted columns queryable — and the
+ * `cipherstash/*@1` codec + `eql_v2_encrypted` native type outputs. They
+ * mirror the `*V2` PSL constructors' `true` defaults declared via
  * `AuthoringArgRef.default`.
  */
 
+import {
+  type AnyEncryptedV3Column,
+  stripDomainSchema,
+  types,
+} from '@cipherstash/stack/eql/v3'
 import {
   CIPHERSTASH_BIGINT_CODEC_ID,
   CIPHERSTASH_BOOLEAN_CODEC_ID,
@@ -28,9 +39,131 @@ import {
   CIPHERSTASH_STRING_CODEC_ID,
   EQL_V2_ENCRYPTED_TYPE,
 } from '../extension-metadata/constants'
+import { toV3CodecId, type V3CastAs } from '../v3/catalog'
+
+// ---------------------------------------------------------------------------
+// v3 factories (derived from the concrete stack columns)
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-column literal inference via the getters, NOT `EncryptedV3Column<infer D>`:
+ * the stack's bundled `.d.ts` drops the private `definition` field's type, so
+ * inferring through the class widens to the constraint. The getters' declared
+ * return types survive d.ts bundling (see
+ * `../extension-metadata/constants-v3.ts` for the full rationale).
+ */
+type EqlTypeFromGetter<C> = C extends { getEqlType(): infer T extends string }
+  ? T
+  : never
+type CapabilitiesFromGetter<C> = C extends { getQueryCapabilities(): infer T }
+  ? T
+  : never
+
+type StripPublic<T extends string> = T extends `public.${infer D}` ? D : never
+
+/**
+ * Literal-preserving authoring descriptor, generic over the concrete stack
+ * column `C`. `codecId`, `nativeType`, and `capabilities` are the domain's
+ * LITERAL types (not `string` / `unknown`), so two domains' factories are
+ * mutually non-assignable — this is the type spine (design "Type Discipline").
+ * `castAs` is the one field the stack widens (`build(): ColumnSchema`), which
+ * is harmless: `nativeType` already discriminates every domain. Pinned by the
+ * type-level tests in `test/v3/column-types.test-d.ts`.
+ */
+export interface V3ColumnDescriptor<C extends AnyEncryptedV3Column> {
+  readonly codecId: `cipherstash/eql-v3/${StripPublic<EqlTypeFromGetter<C>>}@1`
+  readonly nativeType: EqlTypeFromGetter<C>
+  readonly typeParams: {
+    readonly castAs: V3CastAs
+    readonly capabilities: CapabilitiesFromGetter<C>
+  }
+}
+
+/**
+ * Build one authoring factory from a concrete stack `types.*` factory. VALUES
+ * are read from the column (`getEqlType` / `getQueryCapabilities` / `build`) —
+ * nothing is hardcoded — and the codec id goes through the catalog's
+ * `toV3CodecId` (registry key VERBATIM, never a name transform), while the
+ * literal TYPES flow from `C`. The factory set is a typed 1:1 mirror of the
+ * exposed catalog domains, which is how "derive from the catalog" and
+ * "distinct static type per domain" coexist: TypeScript cannot hand distinct
+ * static types to values pulled from a runtime record, so each factory names
+ * its stack factory. Drift is caught by the 1:1 runtime test in
+ * `test/column-types.test.ts` (exposed factory set === catalog minus
+ * `*_ord_ore`) and the catalog drift tests.
+ */
+function v3Authored<C extends AnyEncryptedV3Column>(
+  make: (name: string) => C,
+): () => V3ColumnDescriptor<C> {
+  const probe = make('__probe__')
+  const nativeType = probe.getEqlType()
+  const descriptor = {
+    codecId: toV3CodecId(stripDomainSchema(nativeType)),
+    nativeType,
+    typeParams: {
+      // Narrowing assertion, mirrors ../v3/catalog.ts: `build()` widens
+      // `cast_as` in the bundled d.ts; the value is the domain's literal.
+      castAs: probe.build().cast_as as V3CastAs,
+      capabilities: probe.getQueryCapabilities(),
+    },
+    // Narrowing assertion: runtime strings are the literals the getters
+    // declare; `toV3CodecId` returns `string` by signature.
+  } as V3ColumnDescriptor<C>
+  return () => descriptor
+}
+
+// Each factory has a DISTINCT return type (V3ColumnDescriptor<EncryptedXColumn>);
+// `encryptedBigIntOrd()` is not assignable to `encryptedText()` and vice-versa.
+// Note the stack factory names: bigint is `types.Bigint*` (not `BigInt*`).
+// text family
+export const encryptedText = v3Authored(types.Text)
+export const encryptedTextEq = v3Authored(types.TextEq)
+export const encryptedTextOrd = v3Authored(types.TextOrd)
+export const encryptedTextMatch = v3Authored(types.TextMatch)
+export const encryptedTextSearch = v3Authored(types.TextSearch)
+// integer
+export const encryptedInteger = v3Authored(types.Integer)
+export const encryptedIntegerEq = v3Authored(types.IntegerEq)
+export const encryptedIntegerOrd = v3Authored(types.IntegerOrd)
+// smallint
+export const encryptedSmallint = v3Authored(types.Smallint)
+export const encryptedSmallintEq = v3Authored(types.SmallintEq)
+export const encryptedSmallintOrd = v3Authored(types.SmallintOrd)
+// bigint
+export const encryptedBigInt = v3Authored(types.Bigint)
+export const encryptedBigIntEq = v3Authored(types.BigintEq)
+export const encryptedBigIntOrd = v3Authored(types.BigintOrd)
+// numeric
+export const encryptedNumeric = v3Authored(types.Numeric)
+export const encryptedNumericEq = v3Authored(types.NumericEq)
+export const encryptedNumericOrd = v3Authored(types.NumericOrd)
+// real
+export const encryptedReal = v3Authored(types.Real)
+export const encryptedRealEq = v3Authored(types.RealEq)
+export const encryptedRealOrd = v3Authored(types.RealOrd)
+// double
+export const encryptedDouble = v3Authored(types.Double)
+export const encryptedDoubleEq = v3Authored(types.DoubleEq)
+export const encryptedDoubleOrd = v3Authored(types.DoubleOrd)
+// date
+export const encryptedDate = v3Authored(types.Date)
+export const encryptedDateEq = v3Authored(types.DateEq)
+export const encryptedDateOrd = v3Authored(types.DateOrd)
+// timestamp
+export const encryptedTimestamp = v3Authored(types.Timestamp)
+export const encryptedTimestampEq = v3Authored(types.TimestampEq)
+export const encryptedTimestampOrd = v3Authored(types.TimestampOrd)
+// boolean (storage-only)
+export const encryptedBoolean = v3Authored(types.Boolean)
+// json (encrypted JSONB, ste_vec containment)
+export const encryptedJson = v3Authored(types.Json)
+
+// ---------------------------------------------------------------------------
+// v2 legacy aliases (verbatim pre-rename bodies, now named *V2)
+// ---------------------------------------------------------------------------
 
 /**
- * Search-mode parameters for `encryptedString({...})`. Every flag is
+ * Search-mode parameters for `encryptedStringV2({...})`. Every flag is
  * optional and defaults to `true` when omitted — searchable
  * encryption is the legitimate default. `orderAndRange` gives string
  * columns the same sortable / range-queryable surface the numeric +
@@ -53,16 +186,16 @@ export interface EncryptedStringColumnDescriptor {
 }
 
 /**
- * `encryptedString({ equality?, freeTextSearch?, orderAndRange? })` —
+ * `encryptedStringV2({ equality?, freeTextSearch?, orderAndRange? })` —
  * TS contract factory that lowers to a `ColumnTypeDescriptor` with
  * the `cipherstash/string@1` codec and the `eql_v2_encrypted`
  * Postgres native type. Each boolean flag becomes a `typeParams.*`
  * slot; all default to `true`.
  *
  * The shape matches what the PSL constructor
- * `cipherstash.EncryptedString({...})` lowers to, byte-for-byte.
+ * `cipherstash.EncryptedStringV2({...})` lowers to, byte-for-byte.
  */
-export function encryptedString(
+export function encryptedStringV2(
   options: EncryptedStringOptions = {},
 ): EncryptedStringColumnDescriptor {
   return {
@@ -77,8 +210,8 @@ export function encryptedString(
 }
 
 /**
- * Search-mode parameters for `encryptedDouble({...})` and
- * `encryptedBigInt({...})`. Both flags are optional and default to
+ * Search-mode parameters for `encryptedDoubleV2({...})` and
+ * `encryptedBigIntV2({...})`. Both flags are optional and default to
  * `true` when omitted — searchable encryption is the legitimate
  * default.
  */
@@ -106,13 +239,13 @@ export interface EncryptedBigIntColumnDescriptor {
 }
 
 /**
- * `encryptedDouble({ equality?, orderAndRange? })` — TS contract
+ * `encryptedDoubleV2({ equality?, orderAndRange? })` — TS contract
  * factory that lowers to a `ColumnTypeDescriptor` with the
  * `cipherstash/double@1` codec and the `eql_v2_encrypted` Postgres
  * native type. Mirrors what
- * `cipherstash.EncryptedDouble({...})` lowers to byte-for-byte.
+ * `cipherstash.EncryptedDoubleV2({...})` lowers to byte-for-byte.
  */
-export function encryptedDouble(
+export function encryptedDoubleV2(
   options: EncryptedNumericOptions = {},
 ): EncryptedDoubleColumnDescriptor {
   return {
@@ -126,10 +259,10 @@ export function encryptedDouble(
 }
 
 /**
- * `encryptedBigInt({ equality?, orderAndRange? })` — TS contract
- * factory matching `cipherstash.EncryptedBigInt({...})`.
+ * `encryptedBigIntV2({ equality?, orderAndRange? })` — TS contract
+ * factory matching `cipherstash.EncryptedBigIntV2({...})`.
  */
-export function encryptedBigInt(
+export function encryptedBigIntV2(
   options: EncryptedNumericOptions = {},
 ): EncryptedBigIntColumnDescriptor {
   return {
@@ -143,7 +276,7 @@ export function encryptedBigInt(
 }
 
 /**
- * Search-mode parameters for `encryptedDate({...})`. Both flags are
+ * Search-mode parameters for `encryptedDateV2({...})`. Both flags are
  * optional and default to `true`.
  */
 export interface EncryptedDateOptions {
@@ -161,10 +294,10 @@ export interface EncryptedDateColumnDescriptor {
 }
 
 /**
- * `encryptedDate({ equality?, orderAndRange? })` — TS contract factory
- * matching `cipherstash.EncryptedDate({...})`.
+ * `encryptedDateV2({ equality?, orderAndRange? })` — TS contract factory
+ * matching `cipherstash.EncryptedDateV2({...})`.
  */
-export function encryptedDate(
+export function encryptedDateV2(
   options: EncryptedDateOptions = {},
 ): EncryptedDateColumnDescriptor {
   return {
@@ -178,7 +311,7 @@ export function encryptedDate(
 }
 
 /**
- * Search-mode parameters for `encryptedBoolean({...})`. The flag is
+ * Search-mode parameters for `encryptedBooleanV2({...})`. The flag is
  * optional and defaults to `true`. Booleans only support equality
  * search (no meaningful range predicate over a 2-value domain).
  */
@@ -195,10 +328,10 @@ export interface EncryptedBooleanColumnDescriptor {
 }
 
 /**
- * `encryptedBoolean({ equality? })` — TS contract factory matching
- * `cipherstash.EncryptedBoolean({...})`.
+ * `encryptedBooleanV2({ equality? })` — TS contract factory matching
+ * `cipherstash.EncryptedBooleanV2({...})`.
  */
-export function encryptedBoolean(
+export function encryptedBooleanV2(
   options: EncryptedBooleanOptions = {},
 ): EncryptedBooleanColumnDescriptor {
   return {
@@ -211,7 +344,7 @@ export function encryptedBoolean(
 }
 
 /**
- * Search-mode parameters for `encryptedJson({...})`. Single flag —
+ * Search-mode parameters for `encryptedJsonV2({...})`. Single flag —
  * `searchableJson` gates the entire `ste_vec` index family (containment
  * + path-extraction predicates). Defaults to `true`.
  */
@@ -228,10 +361,10 @@ export interface EncryptedJsonColumnDescriptor {
 }
 
 /**
- * `encryptedJson({ searchableJson? })` — TS contract factory matching
- * `cipherstash.EncryptedJson({...})`.
+ * `encryptedJsonV2({ searchableJson? })` — TS contract factory matching
+ * `cipherstash.EncryptedJsonV2({...})`.
  */
-export function encryptedJson(
+export function encryptedJsonV2(
   options: EncryptedJsonOptions = {},
 ): EncryptedJsonColumnDescriptor {
   return {
diff --git a/packages/prisma-next/src/extension-metadata/constants-v3.ts b/packages/prisma-next/src/extension-metadata/constants-v3.ts
index 30307612..299d12d5 100644
--- a/packages/prisma-next/src/extension-metadata/constants-v3.ts
+++ b/packages/prisma-next/src/extension-metadata/constants-v3.ts
@@ -4,7 +4,10 @@
  * closed union derived from the imported catalog: `(codec id) ⟺ (public.*
  * domain)` is bijective, so the id set IS the catalog.
  */
-import type { AnyEncryptedV3Column, QueryCapabilities } from '@cipherstash/stack/eql/v3'
+import type {
+  AnyEncryptedV3Column,
+  QueryCapabilities,
+} from '@cipherstash/stack/eql/v3'
 import {
   CIPHERSTASH_TRAIT_EQUALITY,
   CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
@@ -103,19 +106,28 @@ export const CIPHERSTASH_V3_CODEC_IDS = [
 // catalog gains a domain that is not pinned above, `Exclude<...>` is non-`never`
 // and this assignment fails to compile with the offending id in the error.
 type _PinnedId = (typeof CIPHERSTASH_V3_CODEC_IDS)[number]
-type _NoUnpinnedDomain = [Exclude<CipherstashV3CodecId, _PinnedId>] extends [never]
+type _NoUnpinnedDomain = [Exclude<CipherstashV3CodecId, _PinnedId>] extends [
+  never,
+]
   ? true
-  : ['catalog gained an unpinned codec id', Exclude<CipherstashV3CodecId, _PinnedId>]
+  : [
+      'catalog gained an unpinned codec id',
+      Exclude<CipherstashV3CodecId, _PinnedId>,
+    ]
 const _driftGuard: _NoUnpinnedDomain = true
 void _driftGuard
 
-export const CIPHERSTASH_V3_CODEC_ID_SET: ReadonlySet<string> = new Set(CIPHERSTASH_V3_CODEC_IDS)
+export const CIPHERSTASH_V3_CODEC_ID_SET: ReadonlySet<string> = new Set(
+  CIPHERSTASH_V3_CODEC_IDS,
+)
 
 export function isCipherstashV3CodecId(id: string): id is CipherstashV3CodecId {
   return CIPHERSTASH_V3_CODEC_ID_SET.has(id)
 }
 
-export function v3TraitsForCapabilities(caps: QueryCapabilities): readonly string[] {
+export function v3TraitsForCapabilities(
+  caps: QueryCapabilities,
+): readonly string[] {
   const traits: string[] = []
   if (caps.equality) traits.push(CIPHERSTASH_TRAIT_EQUALITY)
   if (caps.orderAndRange) traits.push(CIPHERSTASH_TRAIT_ORDER_AND_RANGE)
@@ -124,7 +136,8 @@ export function v3TraitsForCapabilities(caps: QueryCapabilities): readonly strin
   return traits
 }
 
-export const CIPHERSTASH_V3_BASELINE_MIGRATION_NAME = '20260601T0100_install_eql_v3_bundle'
+export const CIPHERSTASH_V3_BASELINE_MIGRATION_NAME =
+  '20260601T0100_install_eql_v3_bundle'
 
 export const CIPHERSTASH_V3_INVARIANTS = {
   installBundle: 'cipherstash:install-eql-v3-bundle-v1',
diff --git a/packages/prisma-next/src/v3/catalog.ts b/packages/prisma-next/src/v3/catalog.ts
index e56b837f..5bb6b3fa 100644
--- a/packages/prisma-next/src/v3/catalog.ts
+++ b/packages/prisma-next/src/v3/catalog.ts
@@ -56,24 +56,31 @@ const registryEntries: ReadonlyArray<readonly [string, V3ColumnFactory]> =
   Object.entries(DOMAIN_REGISTRY)
 
 const metaEntries: Array<readonly [string, V3DomainMeta]> = registryEntries.map(
-  ([bareDomain, factory]) => [toV3CodecId(bareDomain), metaFor(bareDomain, factory)] as const,
+  ([bareDomain, factory]) =>
+    [toV3CodecId(bareDomain), metaFor(bareDomain, factory)] as const,
 )
 
-export const V3_DOMAIN_META_BY_CODEC_ID: ReadonlyMap<string, V3DomainMeta> = new Map(metaEntries)
+export const V3_DOMAIN_META_BY_CODEC_ID: ReadonlyMap<string, V3DomainMeta> =
+  new Map(metaEntries)
 
 export const V3_CODEC_IDS: readonly string[] = metaEntries.map(([id]) => id)
 
 export const V3_FACTORY_BY_NATIVE_TYPE: ReadonlyMap<
   string,
   (name: string) => AnyEncryptedV3Column
-> = new Map(registryEntries.map(([, factory]) => [factory(PROBE).getEqlType(), factory] as const))
+> = new Map(
+  registryEntries.map(
+    ([, factory]) => [factory(PROBE).getEqlType(), factory] as const,
+  ),
+)
 
 export function isOrdOreDomain(bareDomain: string): boolean {
   return bareDomain.endsWith('_ord_ore')
 }
 
-export const EXPOSED_DOMAIN_ENTRIES: ReadonlyArray<readonly [string, V3DomainMeta]> =
-  metaEntries.filter(([, meta]) => !isOrdOreDomain(meta.bareDomain))
+export const EXPOSED_DOMAIN_ENTRIES: ReadonlyArray<
+  readonly [string, V3DomainMeta]
+> = metaEntries.filter(([, meta]) => !isOrdOreDomain(meta.bareDomain))
 
 export function envelopeTypeNameForCastAs(
   castAs: V3CastAs,
diff --git a/packages/prisma-next/test/authoring.test.ts b/packages/prisma-next/test/authoring.test.ts
index c025719e..f83b7842 100644
--- a/packages/prisma-next/test/authoring.test.ts
+++ b/packages/prisma-next/test/authoring.test.ts
@@ -2,31 +2,151 @@
  * Pack-meta authoring contributions for the cipherstash extension.
  *
  * Pinned behaviour:
- *   - Pack-meta exposes `cipherstash.EncryptedString` as a namespaced
- *     `typeConstructor`.
- *   - The constructor takes a single OPTIONAL object argument with
- *     optional boolean `equality` and `freeTextSearch` properties (so
- *     `cipherstash.EncryptedString()` and `cipherstash.EncryptedString({})`
- *     both parse).
- *   - The output template lowers to a `ColumnTypeDescriptor` with
- *     `codecId: 'cipherstash/string@1'`, `nativeType: 'eql_v2_encrypted'`,
- *     and an `AuthoringArgRef`-based `typeParams` block carrying
- *     `true` defaults for both flags — searchable encryption is the
- *     legitimate default; users opt out explicitly.
+ *   - Every exposed v3 domain (the catalog minus `*_ord_ore`) gets exactly
+ *     one concrete, argument-less `typeConstructor` whose name is the
+ *     mechanical `Encrypted<Stem><Suffix>` transform of the bare domain
+ *     (`eql_v3_text_search` → `EncryptedTextSearch`). The output carries the
+ *     domain's STATIC codec id, `public.eql_v3_*` native type, and a static
+ *     `{ castAs, capabilities }` typeParams block — no options, no
+ *     `AuthoringArgRef` nodes.
+ *   - The six pre-existing v2 constructors survive verbatim under their
+ *     `*V2` names (`EncryptedStringV2`, …): same optional-object argument
+ *     shapes, same `cipherstash/*@1` codec ids, same `eql_v2_encrypted`
+ *     native type, same `true`-defaulting `AuthoringArgRef` typeParams.
+ *   - `EncryptedString` (unqualified) no longer exists — v3 text columns use
+ *     the `EncryptedText*` family. `EncryptedJson` (unqualified) is now the
+ *     v3 `eql_v3_json` domain.
  *
  * Full PSL→ColumnTypeDescriptor lowering is exercised in
- * `test/psl-interpretation.test.ts`.
+ * `test/psl-interpretation*.test.ts`.
  */
 
 import { describe, expect, it } from 'vitest'
-import { cipherstashAuthoringTypes } from '../src/contract-authoring'
+import {
+  cipherstashAuthoringTypes,
+  v3PascalName,
+} from '../src/contract-authoring'
 import cipherstashPack from '../src/exports/pack'
+import { EXPOSED_DOMAIN_ENTRIES } from '../src/v3/catalog'
 
-describe('cipherstash pack authoring contributions', () => {
-  it('exposes cipherstash.EncryptedString as a namespaced type constructor', () => {
+type ConstructorView =
+  | {
+      readonly kind: string
+      readonly args?: readonly unknown[]
+      readonly output: Record<string, unknown>
+    }
+  | undefined
+
+// Double cast: the namespace value type is the recursive
+// `AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace` union; the
+// tests read it as the flat constructor record it actually is.
+const ns = cipherstashAuthoringTypes.cipherstash as unknown as Record<
+  string,
+  ConstructorView
+>
+
+describe('cipherstash v3 authoring (concrete per-domain, static descriptors)', () => {
+  it('emits exactly one argument-less constructor per exposed domain, matching the catalog values', () => {
+    for (const [codecId, meta] of EXPOSED_DOMAIN_ENTRIES) {
+      const name = v3PascalName(meta.bareDomain)
+      const ctor = ns[name]
+      expect(ctor, `missing constructor ${name}`).toBeDefined()
+      expect(ctor?.kind).toBe('typeConstructor')
+      expect(ctor?.args ?? []).toEqual([])
+      expect(ctor?.output).toMatchObject({
+        codecId,
+        nativeType: meta.nativeType,
+        typeParams: { castAs: meta.castAs, capabilities: meta.capabilities },
+      })
+    }
+  })
+
+  it('EncryptedTextSearch → public.eql_v3_text_search with full capabilities', () => {
+    expect(ns.EncryptedTextSearch?.output).toMatchObject({
+      codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+      nativeType: 'public.eql_v3_text_search',
+      typeParams: {
+        castAs: 'string',
+        capabilities: {
+          equality: true,
+          orderAndRange: true,
+          freeTextSearch: true,
+        },
+      },
+    })
+  })
+
+  it('EncryptedBoolean → storage-only public.eql_v3_boolean (no equality constructor exists)', () => {
+    expect(ns.EncryptedBoolean?.output).toMatchObject({
+      codecId: 'cipherstash/eql-v3/eql_v3_boolean@1',
+      nativeType: 'public.eql_v3_boolean',
+      typeParams: {
+        castAs: 'boolean',
+        capabilities: {
+          equality: false,
+          orderAndRange: false,
+          freeTextSearch: false,
+        },
+      },
+    })
+    expect(ns.EncryptedBooleanEq).toBeUndefined()
+  })
+
+  it('EncryptedJson → public.eql_v3_json with searchableJson-only capabilities', () => {
+    expect(ns.EncryptedJson?.output).toMatchObject({
+      codecId: 'cipherstash/eql-v3/eql_v3_json@1',
+      nativeType: 'public.eql_v3_json',
+      typeParams: {
+        castAs: 'json',
+        capabilities: {
+          equality: false,
+          orderAndRange: false,
+          freeTextSearch: false,
+          searchableJson: true,
+        },
+      },
+    })
+  })
+
+  it('BigInt family is present (public.eql_v3_bigint*, castAs bigint); no *OrdOre, no v3 String', () => {
+    expect(ns.EncryptedBigInt?.output).toMatchObject({
+      nativeType: 'public.eql_v3_bigint',
+      typeParams: { castAs: 'bigint' },
+    })
+    expect(ns.EncryptedBigIntEq?.output).toMatchObject({
+      nativeType: 'public.eql_v3_bigint_eq',
+    })
+    expect(ns.EncryptedBigIntOrd?.output).toMatchObject({
+      nativeType: 'public.eql_v3_bigint_ord',
+    })
+    expect(ns.EncryptedBigIntOrdOre).toBeUndefined()
+    expect(ns.EncryptedIntegerOrdOre).toBeUndefined()
+    expect(ns.EncryptedTextOrdOre).toBeUndefined()
+    // v3 text columns use EncryptedText*; the unqualified v2 name is gone.
+    expect(ns.EncryptedString).toBeUndefined()
+  })
+
+  it('the exposed constructor set is exactly the derived v3 names plus the six *V2 aliases', () => {
+    const derived = EXPOSED_DOMAIN_ENTRIES.map(([, meta]) =>
+      v3PascalName(meta.bareDomain),
+    )
+    const v2Aliases = [
+      'EncryptedStringV2',
+      'EncryptedDoubleV2',
+      'EncryptedBigIntV2',
+      'EncryptedDateV2',
+      'EncryptedBooleanV2',
+      'EncryptedJsonV2',
+    ]
+    expect(Object.keys(ns).sort()).toEqual([...derived, ...v2Aliases].sort())
+  })
+})
+
+describe('cipherstash pack authoring contributions (v2 legacy aliases)', () => {
+  it('exposes cipherstash.EncryptedStringV2 as a namespaced type constructor', () => {
     expect(cipherstashPack.authoring?.type).toMatchObject({
       cipherstash: {
-        EncryptedString: {
+        EncryptedStringV2: {
           kind: 'typeConstructor',
         },
       },
@@ -34,28 +154,24 @@ describe('cipherstash pack authoring contributions', () => {
   })
 
   it('declares a single optional object argument with optional equality + freeTextSearch + orderAndRange boolean properties', () => {
-    expect(cipherstashAuthoringTypes.cipherstash.EncryptedString).toMatchObject(
-      {
-        kind: 'typeConstructor',
-        args: [
-          {
-            kind: 'object',
-            optional: true,
-            properties: {
-              equality: { kind: 'boolean', optional: true },
-              freeTextSearch: { kind: 'boolean', optional: true },
-              orderAndRange: { kind: 'boolean', optional: true },
-            },
+    expect(ns.EncryptedStringV2).toMatchObject({
+      kind: 'typeConstructor',
+      args: [
+        {
+          kind: 'object',
+          optional: true,
+          properties: {
+            equality: { kind: 'boolean', optional: true },
+            freeTextSearch: { kind: 'boolean', optional: true },
+            orderAndRange: { kind: 'boolean', optional: true },
           },
-        ],
-      },
-    )
+        },
+      ],
+    })
   })
 
   it('lowers to ColumnTypeDescriptor with codecId cipherstash/string@1 + nativeType eql_v2_encrypted, defaulting all flags to true', () => {
-    expect(
-      cipherstashAuthoringTypes.cipherstash.EncryptedString.output,
-    ).toMatchObject({
+    expect(ns.EncryptedStringV2?.output).toMatchObject({
       codecId: 'cipherstash/string@1',
       nativeType: 'eql_v2_encrypted',
       typeParams: {
@@ -85,17 +201,15 @@ describe('cipherstash pack authoring contributions', () => {
     })
   })
 
-  describe('cipherstash.EncryptedDouble', () => {
-    it('exposes EncryptedDouble as a namespaced type constructor', () => {
+  describe('cipherstash.EncryptedDoubleV2', () => {
+    it('exposes EncryptedDoubleV2 as a namespaced type constructor', () => {
       expect(cipherstashPack.authoring?.type).toMatchObject({
-        cipherstash: { EncryptedDouble: { kind: 'typeConstructor' } },
+        cipherstash: { EncryptedDoubleV2: { kind: 'typeConstructor' } },
       })
     })
 
     it('declares { equality, orderAndRange } booleans, defaulting both to true', () => {
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedDouble,
-      ).toMatchObject({
+      expect(ns.EncryptedDoubleV2).toMatchObject({
         kind: 'typeConstructor',
         args: [
           {
@@ -108,9 +222,7 @@ describe('cipherstash pack authoring contributions', () => {
           },
         ],
       })
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedDouble.output,
-      ).toMatchObject({
+      expect(ns.EncryptedDoubleV2?.output).toMatchObject({
         codecId: 'cipherstash/double@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -140,17 +252,15 @@ describe('cipherstash pack authoring contributions', () => {
     })
   })
 
-  describe('cipherstash.EncryptedBigInt', () => {
-    it('exposes EncryptedBigInt as a namespaced type constructor', () => {
+  describe('cipherstash.EncryptedBigIntV2', () => {
+    it('exposes EncryptedBigIntV2 as a namespaced type constructor', () => {
       expect(cipherstashPack.authoring?.type).toMatchObject({
-        cipherstash: { EncryptedBigInt: { kind: 'typeConstructor' } },
+        cipherstash: { EncryptedBigIntV2: { kind: 'typeConstructor' } },
       })
     })
 
     it('lowers to ColumnTypeDescriptor with codecId cipherstash/bigint@1, defaulting both flags to true', () => {
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedBigInt.output,
-      ).toMatchObject({
+      expect(ns.EncryptedBigIntV2?.output).toMatchObject({
         codecId: 'cipherstash/bigint@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -180,17 +290,15 @@ describe('cipherstash pack authoring contributions', () => {
     })
   })
 
-  describe('cipherstash.EncryptedDate', () => {
-    it('exposes EncryptedDate as a namespaced type constructor', () => {
+  describe('cipherstash.EncryptedDateV2', () => {
+    it('exposes EncryptedDateV2 as a namespaced type constructor', () => {
       expect(cipherstashPack.authoring?.type).toMatchObject({
-        cipherstash: { EncryptedDate: { kind: 'typeConstructor' } },
+        cipherstash: { EncryptedDateV2: { kind: 'typeConstructor' } },
       })
     })
 
     it('lowers to ColumnTypeDescriptor with codecId cipherstash/date@1, defaulting both flags to true', () => {
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedDate.output,
-      ).toMatchObject({
+      expect(ns.EncryptedDateV2?.output).toMatchObject({
         codecId: 'cipherstash/date@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -220,17 +328,15 @@ describe('cipherstash pack authoring contributions', () => {
     })
   })
 
-  describe('cipherstash.EncryptedBoolean', () => {
-    it('exposes EncryptedBoolean as a namespaced type constructor', () => {
+  describe('cipherstash.EncryptedBooleanV2', () => {
+    it('exposes EncryptedBooleanV2 as a namespaced type constructor', () => {
       expect(cipherstashPack.authoring?.type).toMatchObject({
-        cipherstash: { EncryptedBoolean: { kind: 'typeConstructor' } },
+        cipherstash: { EncryptedBooleanV2: { kind: 'typeConstructor' } },
       })
     })
 
     it('lowers to ColumnTypeDescriptor with codecId cipherstash/boolean@1, defaulting equality to true', () => {
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedBoolean.output,
-      ).toMatchObject({
+      expect(ns.EncryptedBooleanV2?.output).toMatchObject({
         codecId: 'cipherstash/boolean@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -254,17 +360,15 @@ describe('cipherstash pack authoring contributions', () => {
     })
   })
 
-  describe('cipherstash.EncryptedJson', () => {
-    it('exposes EncryptedJson as a namespaced type constructor', () => {
+  describe('cipherstash.EncryptedJsonV2', () => {
+    it('exposes EncryptedJsonV2 as a namespaced type constructor', () => {
       expect(cipherstashPack.authoring?.type).toMatchObject({
-        cipherstash: { EncryptedJson: { kind: 'typeConstructor' } },
+        cipherstash: { EncryptedJsonV2: { kind: 'typeConstructor' } },
       })
     })
 
     it('lowers to ColumnTypeDescriptor with codecId cipherstash/json@1, defaulting searchableJson to true', () => {
-      expect(
-        cipherstashAuthoringTypes.cipherstash.EncryptedJson.output,
-      ).toMatchObject({
+      expect(ns.EncryptedJsonV2?.output).toMatchObject({
         codecId: 'cipherstash/json@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
diff --git a/packages/prisma-next/test/column-types.test.ts b/packages/prisma-next/test/column-types.test.ts
index fe0ec46f..272381c0 100644
--- a/packages/prisma-next/test/column-types.test.ts
+++ b/packages/prisma-next/test/column-types.test.ts
@@ -1,27 +1,96 @@
 /**
- * TS contract factory for cipherstash-encrypted string columns.
+ * TS contract factories for cipherstash-encrypted columns.
  *
- * The factory must produce a `ColumnTypeDescriptor` byte-identical to
- * the lowering output of the PSL constructor `cipherstash.EncryptedString`
- * registered in `src/contract-authoring.ts`. The full byte-equality is verified
- * by the integration parity fixture; these unit tests pin the shape
- * locally so a regression is caught in the package suite first.
+ * v3: one factory per exposed domain, derived 1:1 from the catalog. Each
+ * factory takes NO options and returns the domain's concrete descriptor —
+ * static codec id, `public.eql_v3_*` native type, and a static
+ * `{ castAs, capabilities }` typeParams block — byte-identical to the
+ * lowering output of the matching PSL constructor in
+ * `src/contract-authoring.ts`.
+ *
+ * v2: the six pre-rename factories survive verbatim under their `*V2`
+ * names (`encryptedStringV2`, …) with their original option arguments and
+ * `eql_v2_encrypted` outputs.
  */
 
 import { describe, expect, it } from 'vitest'
+import { v3CamelName } from '../src/contract-authoring'
+import * as columnTypes from '../src/exports/column-types'
 import {
-  encryptedBigInt,
-  encryptedBoolean,
-  encryptedDate,
-  encryptedDouble,
-  encryptedJson,
-  encryptedString,
+  encryptedBigIntV2,
+  encryptedBooleanV2,
+  encryptedDateV2,
+  encryptedDoubleV2,
+  encryptedJsonV2,
+  encryptedStringV2,
 } from '../src/exports/column-types'
+import { EXPOSED_DOMAIN_ENTRIES } from '../src/v3/catalog'
+
+describe('v3 TS factories', () => {
+  it('one factory per exposed domain, returning the concrete descriptor', () => {
+    for (const [codecId, meta] of EXPOSED_DOMAIN_ENTRIES) {
+      const name = v3CamelName(meta.bareDomain)
+      const fn = (columnTypes as Record<string, unknown>)[name]
+      expect(fn, `missing factory ${name}`).toBeTypeOf('function')
+      expect((fn as () => unknown)()).toEqual({
+        codecId,
+        nativeType: meta.nativeType,
+        typeParams: { castAs: meta.castAs, capabilities: meta.capabilities },
+      })
+    }
+  })
+
+  it('encryptedBigIntOrd() emits public.eql_v3_bigint_ord with bigint castAs', () => {
+    expect(columnTypes.encryptedBigIntOrd()).toMatchObject({
+      codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1',
+      nativeType: 'public.eql_v3_bigint_ord',
+      typeParams: { castAs: 'bigint' },
+    })
+  })
+
+  it('encryptedTextSearch() emits public.eql_v3_text_search with full capabilities', () => {
+    expect(columnTypes.encryptedTextSearch()).toEqual({
+      codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+      nativeType: 'public.eql_v3_text_search',
+      typeParams: {
+        castAs: 'string',
+        capabilities: {
+          equality: true,
+          orderAndRange: true,
+          freeTextSearch: true,
+        },
+      },
+    })
+  })
 
-describe('cipherstash column-types', () => {
-  describe('encryptedString({...}) factory', () => {
+  it('encryptedJson() emits public.eql_v3_json with searchableJson-only capabilities', () => {
+    expect(columnTypes.encryptedJson()).toEqual({
+      codecId: 'cipherstash/eql-v3/eql_v3_json@1',
+      nativeType: 'public.eql_v3_json',
+      typeParams: {
+        castAs: 'json',
+        capabilities: {
+          equality: false,
+          orderAndRange: false,
+          freeTextSearch: false,
+          searchableJson: true,
+        },
+      },
+    })
+  })
+
+  it('exposes no *OrdOre factories and no v3 encryptedString', () => {
+    const exported = columnTypes as Record<string, unknown>
+    expect(exported['encryptedBigIntOrdOre']).toBeUndefined()
+    expect(exported['encryptedTextOrdOre']).toBeUndefined()
+    expect(exported['encryptedString']).toBeUndefined()
+  })
+})
+
+describe('cipherstash column-types (v2 legacy aliases)', () => {
+  describe('encryptedStringV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/string@1 codec id', () => {
-      const descriptor = encryptedString()
+      const descriptor = encryptedStringV2()
       expect(descriptor).toMatchObject({
         codecId: 'cipherstash/string@1',
         nativeType: 'eql_v2_encrypted',
@@ -29,7 +98,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('defaults all flags to true when called with no arguments', () => {
-      expect(encryptedString()).toEqual({
+      expect(encryptedStringV2()).toEqual({
         codecId: 'cipherstash/string@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -41,7 +110,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('defaults all flags to true for an empty options object', () => {
-      expect(encryptedString({})).toEqual({
+      expect(encryptedStringV2({})).toEqual({
         codecId: 'cipherstash/string@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: {
@@ -53,7 +122,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('lets equality be explicitly disabled', () => {
-      expect(encryptedString({ equality: false })).toMatchObject({
+      expect(encryptedStringV2({ equality: false })).toMatchObject({
         typeParams: {
           equality: false,
           freeTextSearch: true,
@@ -63,7 +132,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('lets freeTextSearch be explicitly disabled', () => {
-      expect(encryptedString({ freeTextSearch: false })).toMatchObject({
+      expect(encryptedStringV2({ freeTextSearch: false })).toMatchObject({
         typeParams: {
           equality: true,
           freeTextSearch: false,
@@ -73,7 +142,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('lets orderAndRange be explicitly disabled', () => {
-      expect(encryptedString({ orderAndRange: false })).toMatchObject({
+      expect(encryptedStringV2({ orderAndRange: false })).toMatchObject({
         typeParams: {
           equality: true,
           freeTextSearch: true,
@@ -84,7 +153,7 @@ describe('cipherstash column-types', () => {
 
     it('lets all flags be explicitly disabled (storage-only encryption)', () => {
       expect(
-        encryptedString({
+        encryptedStringV2({
           equality: false,
           freeTextSearch: false,
           orderAndRange: false,
@@ -100,7 +169,7 @@ describe('cipherstash column-types', () => {
 
     it('preserves all flags when explicitly enabled', () => {
       expect(
-        encryptedString({
+        encryptedStringV2({
           equality: true,
           freeTextSearch: true,
           orderAndRange: true,
@@ -116,7 +185,7 @@ describe('cipherstash column-types', () => {
 
     it('returns a structurally equivalent descriptor to the PSL constructor lowering', () => {
       expect(
-        encryptedString({
+        encryptedStringV2({
           equality: true,
           freeTextSearch: true,
           orderAndRange: true,
@@ -133,41 +202,41 @@ describe('cipherstash column-types', () => {
     })
   })
 
-  describe('encryptedDouble({...}) factory', () => {
+  describe('encryptedDoubleV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/double@1 codec id', () => {
-      expect(encryptedDouble()).toMatchObject({
+      expect(encryptedDoubleV2()).toMatchObject({
         codecId: 'cipherstash/double@1',
         nativeType: 'eql_v2_encrypted',
       })
     })
 
     it('defaults both flags to true when called with no arguments', () => {
-      expect(encryptedDouble()).toMatchObject({
+      expect(encryptedDoubleV2()).toMatchObject({
         typeParams: { equality: true, orderAndRange: true },
       })
     })
 
     it('defaults both flags to true for an empty options object', () => {
-      expect(encryptedDouble({})).toMatchObject({
+      expect(encryptedDoubleV2({})).toMatchObject({
         typeParams: { equality: true, orderAndRange: true },
       })
     })
 
     it('lets equality be explicitly disabled', () => {
-      expect(encryptedDouble({ equality: false })).toMatchObject({
+      expect(encryptedDoubleV2({ equality: false })).toMatchObject({
         typeParams: { equality: false, orderAndRange: true },
       })
     })
 
     it('lets orderAndRange be explicitly disabled', () => {
-      expect(encryptedDouble({ orderAndRange: false })).toMatchObject({
+      expect(encryptedDoubleV2({ orderAndRange: false })).toMatchObject({
         typeParams: { equality: true, orderAndRange: false },
       })
     })
 
     it('lets both flags be explicitly disabled (storage-only encryption)', () => {
       expect(
-        encryptedDouble({ equality: false, orderAndRange: false }),
+        encryptedDoubleV2({ equality: false, orderAndRange: false }),
       ).toEqual({
         codecId: 'cipherstash/double@1',
         nativeType: 'eql_v2_encrypted',
@@ -176,23 +245,23 @@ describe('cipherstash column-types', () => {
     })
   })
 
-  describe('encryptedBigInt({...}) factory', () => {
+  describe('encryptedBigIntV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/bigint@1 codec id', () => {
-      expect(encryptedBigInt()).toMatchObject({
+      expect(encryptedBigIntV2()).toMatchObject({
         codecId: 'cipherstash/bigint@1',
         nativeType: 'eql_v2_encrypted',
       })
     })
 
     it('defaults both flags to true when called with no arguments', () => {
-      expect(encryptedBigInt()).toMatchObject({
+      expect(encryptedBigIntV2()).toMatchObject({
         typeParams: { equality: true, orderAndRange: true },
       })
     })
 
     it('lets both flags be explicitly disabled (storage-only encryption)', () => {
       expect(
-        encryptedBigInt({ equality: false, orderAndRange: false }),
+        encryptedBigIntV2({ equality: false, orderAndRange: false }),
       ).toEqual({
         codecId: 'cipherstash/bigint@1',
         nativeType: 'eql_v2_encrypted',
@@ -201,22 +270,24 @@ describe('cipherstash column-types', () => {
     })
   })
 
-  describe('encryptedDate({...}) factory', () => {
+  describe('encryptedDateV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/date@1 codec id', () => {
-      expect(encryptedDate()).toMatchObject({
+      expect(encryptedDateV2()).toMatchObject({
         codecId: 'cipherstash/date@1',
         nativeType: 'eql_v2_encrypted',
       })
     })
 
     it('defaults both flags to true when called with no arguments', () => {
-      expect(encryptedDate()).toMatchObject({
+      expect(encryptedDateV2()).toMatchObject({
         typeParams: { equality: true, orderAndRange: true },
       })
     })
 
     it('lets both flags be explicitly disabled', () => {
-      expect(encryptedDate({ equality: false, orderAndRange: false })).toEqual({
+      expect(
+        encryptedDateV2({ equality: false, orderAndRange: false }),
+      ).toEqual({
         codecId: 'cipherstash/date@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: { equality: false, orderAndRange: false },
@@ -224,16 +295,16 @@ describe('cipherstash column-types', () => {
     })
   })
 
-  describe('encryptedBoolean({...}) factory', () => {
+  describe('encryptedBooleanV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/boolean@1 codec id', () => {
-      expect(encryptedBoolean()).toMatchObject({
+      expect(encryptedBooleanV2()).toMatchObject({
         codecId: 'cipherstash/boolean@1',
         nativeType: 'eql_v2_encrypted',
       })
     })
 
     it('defaults equality to true when called with no arguments', () => {
-      expect(encryptedBoolean()).toEqual({
+      expect(encryptedBooleanV2()).toEqual({
         codecId: 'cipherstash/boolean@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: { equality: true },
@@ -241,7 +312,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('lets equality be explicitly disabled', () => {
-      expect(encryptedBoolean({ equality: false })).toEqual({
+      expect(encryptedBooleanV2({ equality: false })).toEqual({
         codecId: 'cipherstash/boolean@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: { equality: false },
@@ -249,16 +320,16 @@ describe('cipherstash column-types', () => {
     })
   })
 
-  describe('encryptedJson({...}) factory', () => {
+  describe('encryptedJsonV2({...}) factory', () => {
     it('produces a ColumnTypeDescriptor with cipherstash/json@1 codec id', () => {
-      expect(encryptedJson()).toMatchObject({
+      expect(encryptedJsonV2()).toMatchObject({
         codecId: 'cipherstash/json@1',
         nativeType: 'eql_v2_encrypted',
       })
     })
 
     it('defaults searchableJson to true when called with no arguments', () => {
-      expect(encryptedJson()).toEqual({
+      expect(encryptedJsonV2()).toEqual({
         codecId: 'cipherstash/json@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: { searchableJson: true },
@@ -266,7 +337,7 @@ describe('cipherstash column-types', () => {
     })
 
     it('lets searchableJson be explicitly disabled (storage-only encryption)', () => {
-      expect(encryptedJson({ searchableJson: false })).toEqual({
+      expect(encryptedJsonV2({ searchableJson: false })).toEqual({
         codecId: 'cipherstash/json@1',
         nativeType: 'eql_v2_encrypted',
         typeParams: { searchableJson: false },
diff --git a/packages/prisma-next/test/psl-interpretation-numeric.test.ts b/packages/prisma-next/test/psl-interpretation-numeric.test.ts
index 8769f97c..9751b298 100644
--- a/packages/prisma-next/test/psl-interpretation-numeric.test.ts
+++ b/packages/prisma-next/test/psl-interpretation-numeric.test.ts
@@ -1,6 +1,6 @@
 /**
  * PSL→ColumnTypeDescriptor lowering for the numeric cipherstash
- * constructors: `cipherstash.EncryptedDouble` / `cipherstash.EncryptedBigInt`.
+ * constructors: `cipherstash.EncryptedDoubleV2` / `cipherstash.EncryptedBigIntV2`.
  *
  * Pinned behaviour for numeric codecs (shared by both):
  *   - Full args lower to `typeParams { equality, orderAndRange }`.
@@ -84,11 +84,11 @@ const asStorage = (storage: unknown): StorageView => {
   }
 }
 
-describe('PSL interpretation: cipherstash.EncryptedDouble constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedDoubleV2 constructor', () => {
   it('lowers full args to a column with cipherstash/double@1 codec, eql_v2_encrypted nativeType', () => {
     const result = interpret(`model Metric {
   id Int @id
-  value cipherstash.EncryptedDouble({ equality: true, orderAndRange: true })
+  value cipherstash.EncryptedDoubleV2({ equality: true, orderAndRange: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -106,7 +106,7 @@ describe('PSL interpretation: cipherstash.EncryptedDouble constructor', () => {
   it('defaults both flags to true for an empty options literal', () => {
     const result = interpret(`model Metric {
   id Int @id
-  value cipherstash.EncryptedDouble({})
+  value cipherstash.EncryptedDoubleV2({})
 }
 `)
     expect(result.ok).toBe(true)
@@ -122,7 +122,7 @@ describe('PSL interpretation: cipherstash.EncryptedDouble constructor', () => {
   it('rejects unknown argument names with PSL_INVALID_ATTRIBUTE_ARGUMENT', () => {
     const result = interpret(`model Metric {
   id Int @id
-  value cipherstash.EncryptedDouble({ freeTextSearch: true })
+  value cipherstash.EncryptedDoubleV2({ freeTextSearch: true })
 }
 `)
     expect(result.ok).toBe(false)
@@ -140,7 +140,7 @@ describe('PSL interpretation: cipherstash.EncryptedDouble constructor', () => {
   it('produces an inline-form descriptor structurally identical to the TS factory output', () => {
     const result = interpret(`model Metric {
   id Int @id
-  value cipherstash.EncryptedDouble({ equality: true, orderAndRange: false })
+  value cipherstash.EncryptedDoubleV2({ equality: true, orderAndRange: false })
 }
 `)
     expect(result.ok).toBe(true)
@@ -158,11 +158,11 @@ describe('PSL interpretation: cipherstash.EncryptedDouble constructor', () => {
   })
 })
 
-describe('PSL interpretation: cipherstash.EncryptedBigInt constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedBigIntV2 constructor', () => {
   it('lowers full args to a column with cipherstash/bigint@1 codec, eql_v2_encrypted nativeType', () => {
     const result = interpret(`model Ledger {
   id Int @id
-  amount cipherstash.EncryptedBigInt({ equality: true, orderAndRange: true })
+  amount cipherstash.EncryptedBigIntV2({ equality: true, orderAndRange: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -179,7 +179,7 @@ describe('PSL interpretation: cipherstash.EncryptedBigInt constructor', () => {
   it('defaults both flags to true with no arguments', () => {
     const result = interpret(`model Ledger {
   id Int @id
-  amount cipherstash.EncryptedBigInt()
+  amount cipherstash.EncryptedBigIntV2()
 }
 `)
     expect(result.ok).toBe(true)
@@ -195,7 +195,7 @@ describe('PSL interpretation: cipherstash.EncryptedBigInt constructor', () => {
   it('rejects unknown argument names with PSL_INVALID_ATTRIBUTE_ARGUMENT', () => {
     const result = interpret(`model Ledger {
   id Int @id
-  amount cipherstash.EncryptedBigInt({ freeTextSearch: true })
+  amount cipherstash.EncryptedBigIntV2({ freeTextSearch: true })
 }
 `)
     expect(result.ok).toBe(false)
diff --git a/packages/prisma-next/test/psl-interpretation-other-types.test.ts b/packages/prisma-next/test/psl-interpretation-other-types.test.ts
index f1a7ab21..8bd952e4 100644
--- a/packages/prisma-next/test/psl-interpretation-other-types.test.ts
+++ b/packages/prisma-next/test/psl-interpretation-other-types.test.ts
@@ -2,10 +2,10 @@
  * PSL→ColumnTypeDescriptor lowering for the date, boolean, and JSON
  * cipherstash constructors:
  *
- *   - `cipherstash.EncryptedDate`    — `{ equality, orderAndRange }`
- *   - `cipherstash.EncryptedBoolean` — `{ equality }` only;
+ *   - `cipherstash.EncryptedDateV2`    — `{ equality, orderAndRange }`
+ *   - `cipherstash.EncryptedBooleanV2` — `{ equality }` only;
  *     `orderAndRange` is rejected with `PSL_INVALID_ATTRIBUTE_ARGUMENT`.
- *   - `cipherstash.EncryptedJson`    — `{ searchableJson }`;
+ *   - `cipherstash.EncryptedJsonV2`    — `{ searchableJson }`;
  *     `equality` is rejected with `PSL_INVALID_ATTRIBUTE_ARGUMENT`.
  *
  * Empty `{}` (and the no-args form) defaults the codec's flag(s) to
@@ -85,11 +85,11 @@ const asStorage = (storage: unknown): StorageView => {
   }
 }
 
-describe('PSL interpretation: cipherstash.EncryptedDate constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedDateV2 constructor', () => {
   it('lowers full args to a column with cipherstash/date@1 codec, eql_v2_encrypted nativeType', () => {
     const result = interpret(`model Event {
   id Int @id
-  occurredOn cipherstash.EncryptedDate({ equality: true, orderAndRange: true })
+  occurredOn cipherstash.EncryptedDateV2({ equality: true, orderAndRange: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -106,7 +106,7 @@ describe('PSL interpretation: cipherstash.EncryptedDate constructor', () => {
   it('defaults both flags to true with no arguments', () => {
     const result = interpret(`model Event {
   id Int @id
-  occurredOn cipherstash.EncryptedDate()
+  occurredOn cipherstash.EncryptedDateV2()
 }
 `)
     expect(result.ok).toBe(true)
@@ -120,11 +120,11 @@ describe('PSL interpretation: cipherstash.EncryptedDate constructor', () => {
   })
 })
 
-describe('PSL interpretation: cipherstash.EncryptedBoolean constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedBooleanV2 constructor', () => {
   it('lowers full args to a column with cipherstash/boolean@1 codec, equality typeParam', () => {
     const result = interpret(`model Feature {
   id Int @id
-  enabled cipherstash.EncryptedBoolean({ equality: true })
+  enabled cipherstash.EncryptedBooleanV2({ equality: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -141,7 +141,7 @@ describe('PSL interpretation: cipherstash.EncryptedBoolean constructor', () => {
   it('defaults equality to true with no arguments', () => {
     const result = interpret(`model Feature {
   id Int @id
-  enabled cipherstash.EncryptedBoolean()
+  enabled cipherstash.EncryptedBooleanV2()
 }
 `)
     expect(result.ok).toBe(true)
@@ -157,7 +157,7 @@ describe('PSL interpretation: cipherstash.EncryptedBoolean constructor', () => {
   it('rejects orderAndRange (not a boolean codec flag)', () => {
     const result = interpret(`model Feature {
   id Int @id
-  enabled cipherstash.EncryptedBoolean({ orderAndRange: true })
+  enabled cipherstash.EncryptedBooleanV2({ orderAndRange: true })
 }
 `)
     expect(result.ok).toBe(false)
@@ -173,11 +173,11 @@ describe('PSL interpretation: cipherstash.EncryptedBoolean constructor', () => {
   })
 })
 
-describe('PSL interpretation: cipherstash.EncryptedJson constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedJsonV2 constructor', () => {
   it('lowers full args to a column with cipherstash/json@1 codec, searchableJson typeParam', () => {
     const result = interpret(`model Audit {
   id Int @id
-  payload cipherstash.EncryptedJson({ searchableJson: true })
+  payload cipherstash.EncryptedJsonV2({ searchableJson: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -194,7 +194,7 @@ describe('PSL interpretation: cipherstash.EncryptedJson constructor', () => {
   it('defaults searchableJson to true with no arguments', () => {
     const result = interpret(`model Audit {
   id Int @id
-  payload cipherstash.EncryptedJson()
+  payload cipherstash.EncryptedJsonV2()
 }
 `)
     expect(result.ok).toBe(true)
@@ -210,7 +210,7 @@ describe('PSL interpretation: cipherstash.EncryptedJson constructor', () => {
   it('rejects equality (not a json codec flag)', () => {
     const result = interpret(`model Audit {
   id Int @id
-  payload cipherstash.EncryptedJson({ equality: true })
+  payload cipherstash.EncryptedJsonV2({ equality: true })
 }
 `)
     expect(result.ok).toBe(false)
diff --git a/packages/prisma-next/test/psl-interpretation.test.ts b/packages/prisma-next/test/psl-interpretation.test.ts
index aa4b4e4d..9c1b1fe4 100644
--- a/packages/prisma-next/test/psl-interpretation.test.ts
+++ b/packages/prisma-next/test/psl-interpretation.test.ts
@@ -1,6 +1,6 @@
 /**
  * Full PSL→ColumnTypeDescriptor lowering for the
- * `cipherstash.EncryptedString({...})` constructor.
+ * `cipherstash.EncryptedStringV2({...})` constructor.
  *
  * Exercises the interpreter end-to-end (parser → authoring contributions
  * → SQL contract IR) so the assertions are about *what users observe*
@@ -21,11 +21,15 @@
  *     the inline-form column's codec/nativeType/typeParams
  *     byte-for-byte.
  *
- * Sister files cover the other cipherstash constructors:
+ * Sister files cover the other v2 cipherstash constructors:
  *   - `psl-interpretation-numeric.test.ts`
- *     (`EncryptedDouble`, `EncryptedBigInt`)
+ *     (`EncryptedDoubleV2`, `EncryptedBigIntV2`)
  *   - `psl-interpretation-other-types.test.ts`
- *     (`EncryptedDate`, `EncryptedBoolean`, `EncryptedJson`)
+ *     (`EncryptedDateV2`, `EncryptedBooleanV2`, `EncryptedJsonV2`)
+ *
+ * The final describe block pins the v3 lowering path: argument-less
+ * constructors with STATIC `{ castAs, capabilities }` typeParams (no
+ * `AuthoringArgRef` resolution involved), and rejection of options.
  */
 
 import type { Contract } from '@prisma-next/contract/types'
@@ -101,11 +105,11 @@ const asStorage = (storage: unknown): StorageView => {
   }
 }
 
-describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
+describe('PSL interpretation: cipherstash.EncryptedStringV2 constructor', () => {
   it('lowers full args to a column with codecId, nativeType, typeParams', () => {
     const result = interpret(`model User {
   id Int @id
-  email cipherstash.EncryptedString({ equality: true, freeTextSearch: true, orderAndRange: true })
+  email cipherstash.EncryptedStringV2({ equality: true, freeTextSearch: true, orderAndRange: true })
 }
 `)
     expect(result.ok).toBe(true)
@@ -129,7 +133,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('defaults all flags to true for an empty options literal', () => {
     const result = interpret(`model User {
   id Int @id
-  notes cipherstash.EncryptedString({})
+  notes cipherstash.EncryptedStringV2({})
 }
 `)
     expect(result.ok).toBe(true)
@@ -153,7 +157,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('defaults all flags to true when called with no arguments', () => {
     const result = interpret(`model User {
   id Int @id
-  notes cipherstash.EncryptedString()
+  notes cipherstash.EncryptedStringV2()
 }
 `)
     expect(result.ok).toBe(true)
@@ -177,7 +181,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('lets orderAndRange be explicitly disabled', () => {
     const result = interpret(`model User {
   id Int @id
-  notes cipherstash.EncryptedString({ orderAndRange: false })
+  notes cipherstash.EncryptedStringV2({ orderAndRange: false })
 }
 `)
     expect(result.ok).toBe(true)
@@ -199,7 +203,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('lets equality be explicitly disabled', () => {
     const result = interpret(`model User {
   id Int @id
-  notes cipherstash.EncryptedString({ equality: false })
+  notes cipherstash.EncryptedStringV2({ equality: false })
 }
 `)
     expect(result.ok).toBe(true)
@@ -217,7 +221,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('lets both flags be explicitly disabled (storage-only encryption)', () => {
     const result = interpret(`model User {
   id Int @id
-  notes cipherstash.EncryptedString({ equality: false, freeTextSearch: false })
+  notes cipherstash.EncryptedStringV2({ equality: false, freeTextSearch: false })
 }
 `)
     expect(result.ok).toBe(true)
@@ -235,7 +239,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('marks nullable columns as nullable', () => {
     const result = interpret(`model User {
   id Int @id
-  username cipherstash.EncryptedString({ freeTextSearch: false })?
+  username cipherstash.EncryptedStringV2({ freeTextSearch: false })?
 }
 `)
     expect(result.ok).toBe(true)
@@ -253,7 +257,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('rejects unknown argument names with PSL_INVALID_ATTRIBUTE_ARGUMENT', () => {
     const result = interpret(`model User {
   id Int @id
-  email cipherstash.EncryptedString({ unknownFlag: true })
+  email cipherstash.EncryptedStringV2({ unknownFlag: true })
 }
 `)
     expect(result.ok).toBe(false)
@@ -271,7 +275,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
   it('rejects wrong-typed argument values with PSL_INVALID_ATTRIBUTE_ARGUMENT', () => {
     const result = interpret(`model User {
   id Int @id
-  email cipherstash.EncryptedString({ equality: "yes" })
+  email cipherstash.EncryptedStringV2({ equality: "yes" })
 }
 `)
     expect(result.ok).toBe(false)
@@ -288,7 +292,7 @@ describe('PSL interpretation: cipherstash.EncryptedString constructor', () => {
 
   it('resolves a named-type alias under types {} and uses it on a model field', () => {
     const result = interpret(`types {
-  SearchableEmail = cipherstash.EncryptedString({ freeTextSearch: false })
+  SearchableEmail = cipherstash.EncryptedStringV2({ freeTextSearch: false })
 }
 
 model User {
@@ -314,7 +318,7 @@ model User {
 
   it('produces an alias whose typeParams match the inline-constructor form for the same args', () => {
     const aliasResult = interpret(`types {
-  SearchableEmail = cipherstash.EncryptedString({ equality: true, freeTextSearch: true })
+  SearchableEmail = cipherstash.EncryptedStringV2({ equality: true, freeTextSearch: true })
 }
 
 model User {
@@ -324,7 +328,7 @@ model User {
 `)
     const inlineResult = interpret(`model User {
   id Int @id
-  email cipherstash.EncryptedString({ equality: true, freeTextSearch: true })
+  email cipherstash.EncryptedStringV2({ equality: true, freeTextSearch: true })
 }
 `)
     expect(aliasResult.ok).toBe(true)
@@ -356,7 +360,7 @@ model User {
   it('reports a span at the offending argument value', () => {
     const result = interpret(`model User {
   id Int @id
-  email cipherstash.EncryptedString({ equality: 42 })
+  email cipherstash.EncryptedStringV2({ equality: 42 })
 }
 `)
     expect(result.ok).toBe(false)
@@ -370,3 +374,94 @@ model User {
     })
   })
 })
+
+describe('PSL interpretation: v3 argument-less constructors (static typeParams)', () => {
+  it('lowers cipherstash.EncryptedTextSearch() to the static v3 descriptor', () => {
+    const result = interpret(`model User {
+  id Int @id
+  email cipherstash.EncryptedTextSearch()
+}
+`)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(
+      asStorage(result.value.storage).tables['user']?.columns['email'],
+    ).toEqual(
+      expect.objectContaining({
+        codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+        nativeType: 'public.eql_v3_text_search',
+        typeParams: {
+          castAs: 'string',
+          capabilities: {
+            equality: true,
+            orderAndRange: true,
+            freeTextSearch: true,
+          },
+        },
+        nullable: false,
+      }),
+    )
+  })
+
+  it('lowers cipherstash.EncryptedBoolean() to the storage-only v3 descriptor', () => {
+    const result = interpret(`model User {
+  id Int @id
+  enabled cipherstash.EncryptedBoolean()
+}
+`)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(
+      asStorage(result.value.storage).tables['user']?.columns['enabled'],
+    ).toEqual(
+      expect.objectContaining({
+        codecId: 'cipherstash/eql-v3/eql_v3_boolean@1',
+        nativeType: 'public.eql_v3_boolean',
+        typeParams: {
+          castAs: 'boolean',
+          capabilities: {
+            equality: false,
+            orderAndRange: false,
+            freeTextSearch: false,
+          },
+        },
+      }),
+    )
+  })
+
+  it('lowers cipherstash.EncryptedJson() with searchableJson-only capabilities', () => {
+    const result = interpret(`model User {
+  id Int @id
+  payload cipherstash.EncryptedJson()
+}
+`)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(
+      asStorage(result.value.storage).tables['user']?.columns['payload'],
+    ).toEqual(
+      expect.objectContaining({
+        codecId: 'cipherstash/eql-v3/eql_v3_json@1',
+        nativeType: 'public.eql_v3_json',
+        typeParams: {
+          castAs: 'json',
+          capabilities: {
+            equality: false,
+            orderAndRange: false,
+            freeTextSearch: false,
+            searchableJson: true,
+          },
+        },
+      }),
+    )
+  })
+
+  it('rejects options on a v3 constructor (they take no arguments)', () => {
+    const result = interpret(`model User {
+  id Int @id
+  email cipherstash.EncryptedTextSearch({ equality: false })
+}
+`)
+    expect(result.ok).toBe(false)
+  })
+})
diff --git a/packages/prisma-next/test/v3/catalog-invariants.test.ts b/packages/prisma-next/test/v3/catalog-invariants.test.ts
index efa62318..ce6e324b 100644
--- a/packages/prisma-next/test/v3/catalog-invariants.test.ts
+++ b/packages/prisma-next/test/v3/catalog-invariants.test.ts
@@ -1,33 +1,50 @@
 import { DOMAIN_REGISTRY } from '@cipherstash/stack/eql/v3'
 import { describe, expect, it } from 'vitest'
-import { EXPOSED_DOMAIN_ENTRIES, V3_DOMAIN_META_BY_CODEC_ID } from '../../src/v3/catalog'
+import {
+  EXPOSED_DOMAIN_ENTRIES,
+  V3_DOMAIN_META_BY_CODEC_ID,
+} from '../../src/v3/catalog'
 
 describe('FFI catalog invariants (non-structural — pinned)', () => {
   const bareDomains = Object.keys(DOMAIN_REGISTRY)
 
   it('exposes json as a first-class searchable-JSON domain (ste_vec, no scalar caps)', () => {
-    expect(bareDomains.filter((d) => d.includes('json'))).toEqual(['eql_v3_json'])
-    const json = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_json@1')
+    expect(bareDomains.filter((d) => d.includes('json'))).toEqual([
+      'eql_v3_json',
+    ])
+    const json = V3_DOMAIN_META_BY_CODEC_ID.get(
+      'cipherstash/eql-v3/eql_v3_json@1',
+    )
     expect(json?.nativeType).toBe('public.eql_v3_json')
     expect(json?.capabilities.searchableJson).toBe(true)
     expect(json?.capabilities.equality).toBe(false)
     expect(Object.keys(json?.indexes ?? {})).toEqual(['ste_vec'])
-    expect(EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json')).toBe(true)
+    expect(
+      EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json'),
+    ).toBe(true)
   })
 
   it('public.eql_v3_boolean is storage-only (advertises no equality, no indexes)', () => {
-    const bool = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_boolean@1')
+    const bool = V3_DOMAIN_META_BY_CODEC_ID.get(
+      'cipherstash/eql-v3/eql_v3_boolean@1',
+    )
     expect(bool?.nativeType).toBe('public.eql_v3_boolean')
     expect(bool?.capabilities.equality).toBe(false)
     expect(Object.keys(bool?.indexes ?? {})).toEqual([])
     // there is only one boolean domain (no boolean_eq)
-    expect(bareDomains.filter((d) => d.startsWith('eql_v3_boolean'))).toEqual(['eql_v3_boolean'])
+    expect(bareDomains.filter((d) => d.startsWith('eql_v3_boolean'))).toEqual([
+      'eql_v3_boolean',
+    ])
   })
 
   it('the BigInt family IS exposed (base/_eq/_ord), *OrdOre is not', () => {
     const exposedBare = EXPOSED_DOMAIN_ENTRIES.map(([, m]) => m.bareDomain)
     expect(exposedBare).toEqual(
-      expect.arrayContaining(['eql_v3_bigint', 'eql_v3_bigint_eq', 'eql_v3_bigint_ord']),
+      expect.arrayContaining([
+        'eql_v3_bigint',
+        'eql_v3_bigint_eq',
+        'eql_v3_bigint_ord',
+      ]),
     )
     expect(exposedBare).not.toContain('eql_v3_bigint_ord_ore')
     expect(exposedBare.some((b) => b.endsWith('_ord_ore'))).toBe(false)
@@ -39,7 +56,10 @@ describe('FFI catalog invariants (non-structural — pinned)', () => {
       if (meta.bareDomain.endsWith('_ord_ore')) {
         expect(indexKeys).toContain('ore')
         expect(indexKeys).not.toContain('ope')
-      } else if (meta.bareDomain.endsWith('_ord') || meta.bareDomain === 'eql_v3_text_search') {
+      } else if (
+        meta.bareDomain.endsWith('_ord') ||
+        meta.bareDomain === 'eql_v3_text_search'
+      ) {
         expect(indexKeys).toContain('ope')
         expect(indexKeys).not.toContain('ore')
       }
diff --git a/packages/prisma-next/test/v3/catalog.test.ts b/packages/prisma-next/test/v3/catalog.test.ts
index d04b0d89..31197523 100644
--- a/packages/prisma-next/test/v3/catalog.test.ts
+++ b/packages/prisma-next/test/v3/catalog.test.ts
@@ -11,41 +11,73 @@ import {
 
 describe('v3 catalog derivation', () => {
   it('derives a concrete codec id per domain from the registry key verbatim', () => {
-    expect(toV3CodecId('eql_v3_text_search')).toBe('cipherstash/eql-v3/eql_v3_text_search@1')
-    expect(toV3CodecId('eql_v3_boolean')).toBe('cipherstash/eql-v3/eql_v3_boolean@1')
+    expect(toV3CodecId('eql_v3_text_search')).toBe(
+      'cipherstash/eql-v3/eql_v3_text_search@1',
+    )
+    expect(toV3CodecId('eql_v3_boolean')).toBe(
+      'cipherstash/eql-v3/eql_v3_boolean@1',
+    )
   })
 
   it('records the public.* native type (never eql_v3.*) for text_search with full caps', () => {
-    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_text_search@1')
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get(
+      'cipherstash/eql-v3/eql_v3_text_search@1',
+    )
     expect(meta?.nativeType).toBe('public.eql_v3_text_search')
     expect(meta?.nativeType.startsWith('public.')).toBe(true)
     expect(meta?.castAs).toBe('string')
-    expect(meta?.capabilities).toEqual({ equality: true, orderAndRange: true, freeTextSearch: true })
-    expect(Object.keys(meta?.indexes ?? {}).sort()).toEqual(['match', 'ope', 'unique'])
+    expect(meta?.capabilities).toEqual({
+      equality: true,
+      orderAndRange: true,
+      freeTextSearch: true,
+    })
+    expect(Object.keys(meta?.indexes ?? {}).sort()).toEqual([
+      'match',
+      'ope',
+      'unique',
+    ])
   })
 
   it('marks public.eql_v3_boolean as storage-only (no indexes, all capabilities false)', () => {
-    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_boolean@1')
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get(
+      'cipherstash/eql-v3/eql_v3_boolean@1',
+    )
     expect(meta?.nativeType).toBe('public.eql_v3_boolean')
     expect(meta?.castAs).toBe('boolean')
-    expect(meta?.capabilities).toEqual({ equality: false, orderAndRange: false, freeTextSearch: false })
+    expect(meta?.capabilities).toEqual({
+      equality: false,
+      orderAndRange: false,
+      freeTextSearch: false,
+    })
     expect(Object.keys(meta?.indexes ?? {})).toEqual([])
   })
 
   it('exposes bigint as a first-class family with bigint castAs', () => {
-    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint@1')?.castAs).toBe('bigint')
-    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint_ord@1')?.nativeType).toBe(
-      'public.eql_v3_bigint_ord',
-    )
+    expect(
+      V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint@1')
+        ?.castAs,
+    ).toBe('bigint')
+    expect(
+      V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_bigint_ord@1')
+        ?.nativeType,
+    ).toBe('public.eql_v3_bigint_ord')
   })
 
   it('derives timestamp castAs distinctly from date', () => {
-    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_timestamp@1')?.castAs).toBe('timestamp')
-    expect(V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_date@1')?.castAs).toBe('date')
+    expect(
+      V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_timestamp@1')
+        ?.castAs,
+    ).toBe('timestamp')
+    expect(
+      V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_date@1')
+        ?.castAs,
+    ).toBe('date')
   })
 
   it('exposes json as a first-class searchable-JSON domain (ste_vec index)', () => {
-    const meta = V3_DOMAIN_META_BY_CODEC_ID.get('cipherstash/eql-v3/eql_v3_json@1')
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get(
+      'cipherstash/eql-v3/eql_v3_json@1',
+    )
     expect(meta?.nativeType).toBe('public.eql_v3_json')
     expect(meta?.castAs).toBe('json')
     expect(meta?.capabilities).toEqual({
@@ -55,7 +87,9 @@ describe('v3 catalog derivation', () => {
       searchableJson: true,
     })
     expect(Object.keys(meta?.indexes ?? {})).toEqual(['ste_vec'])
-    expect(EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json')).toBe(true)
+    expect(
+      EXPOSED_DOMAIN_ENTRIES.some(([, m]) => m.bareDomain === 'eql_v3_json'),
+    ).toBe(true)
   })
 
   it('maps native type back to its concrete factory', () => {
@@ -75,9 +109,15 @@ describe('v3 catalog derivation', () => {
   })
 
   it('includes *_ord_ore in the full meta but excludes it from the exposed entries', () => {
-    expect(V3_DOMAIN_META_BY_CODEC_ID.has('cipherstash/eql-v3/eql_v3_integer_ord_ore@1')).toBe(true)
+    expect(
+      V3_DOMAIN_META_BY_CODEC_ID.has(
+        'cipherstash/eql-v3/eql_v3_integer_ord_ore@1',
+      ),
+    ).toBe(true)
     expect(isOrdOreDomain('eql_v3_integer_ord_ore')).toBe(true)
-    const exposedBare = new Set(EXPOSED_DOMAIN_ENTRIES.map(([, m]) => m.bareDomain))
+    const exposedBare = new Set(
+      EXPOSED_DOMAIN_ENTRIES.map(([, m]) => m.bareDomain),
+    )
     expect([...exposedBare].some((b) => b.endsWith('_ord_ore'))).toBe(false)
     expect(exposedBare.has('eql_v3_integer_ord')).toBe(true)
     expect(exposedBare.has('eql_v3_bigint')).toBe(true)
@@ -85,6 +125,7 @@ describe('v3 catalog derivation', () => {
 
   it('every codec id is v3-namespaced and unique', () => {
     expect(new Set(V3_CODEC_IDS).size).toBe(V3_CODEC_IDS.length)
-    for (const id of V3_CODEC_IDS) expect(id.startsWith('cipherstash/eql-v3/')).toBe(true)
+    for (const id of V3_CODEC_IDS)
+      expect(id.startsWith('cipherstash/eql-v3/')).toBe(true)
   })
 })
diff --git a/packages/prisma-next/test/v3/column-types.test-d.ts b/packages/prisma-next/test/v3/column-types.test-d.ts
new file mode 100644
index 00000000..bb5329db
--- /dev/null
+++ b/packages/prisma-next/test/v3/column-types.test-d.ts
@@ -0,0 +1,45 @@
+/**
+ * Type-level tests for the v3 TS factories' literal spine (design "Type
+ * Discipline"). A runtime suite cannot protect this: if the bundled stack
+ * `.d.ts` ever widens the getters (see the `EqlTypeFromGetter` rationale in
+ * `src/exports/column-types.ts`), every factory still RETURNS the right
+ * values at runtime — only the compile-time discrimination silently
+ * disappears. These assertions fail `tsc --noEmit` the moment that happens.
+ */
+
+import type { QueryCapabilities } from '@cipherstash/stack/eql/v3'
+import { expectTypeOf } from 'vitest'
+import {
+  encryptedBigIntOrd,
+  encryptedText,
+  encryptedTextEq,
+} from '../../src/exports/column-types'
+
+// 1. Factories are mutually non-assignable — distinct type per domain.
+expectTypeOf(encryptedTextEq()).not.toMatchTypeOf(encryptedText())
+expectTypeOf(encryptedBigIntOrd()).not.toMatchTypeOf(encryptedText())
+expectTypeOf(encryptedText()).not.toMatchTypeOf(encryptedBigIntOrd())
+
+// 2. codecId is the literal union member, not `string`.
+expectTypeOf(
+  encryptedTextEq().codecId,
+).toEqualTypeOf<'cipherstash/eql-v3/eql_v3_text_eq@1'>()
+expectTypeOf(
+  encryptedBigIntOrd().codecId,
+).toEqualTypeOf<'cipherstash/eql-v3/eql_v3_bigint_ord@1'>()
+
+// 3. nativeType is the `public.eql_v3_*` literal, not `string`.
+expectTypeOf(
+  encryptedTextEq().nativeType,
+).toEqualTypeOf<'public.eql_v3_text_eq'>()
+expectTypeOf(
+  encryptedBigIntOrd().nativeType,
+).toEqualTypeOf<'public.eql_v3_bigint_ord'>()
+
+// 4. capabilities is (at least) the concrete QueryCapabilities, never `unknown`.
+//    (The stack types each domain's capabilities as literal booleans, so this
+//    also narrows further — the point is it is NOT `unknown`.)
+expectTypeOf(
+  encryptedTextEq().typeParams.capabilities,
+).toMatchTypeOf<QueryCapabilities>()
+expectTypeOf(encryptedTextEq().typeParams.capabilities).not.toBeUnknown()
diff --git a/packages/prisma-next/test/v3/constants-v3.test.ts b/packages/prisma-next/test/v3/constants-v3.test.ts
index 720b0d38..5de40144 100644
--- a/packages/prisma-next/test/v3/constants-v3.test.ts
+++ b/packages/prisma-next/test/v3/constants-v3.test.ts
@@ -23,7 +23,9 @@ describe('constants-v3', () => {
     // or reordering a domain). Both directions must hold.
     expect(new Set(CIPHERSTASH_V3_CODEC_IDS)).toEqual(new Set(V3_CODEC_IDS))
     expect(CIPHERSTASH_V3_CODEC_IDS.length).toBe(V3_CODEC_IDS.length)
-    expect(new Set(CIPHERSTASH_V3_CODEC_IDS).size).toBe(CIPHERSTASH_V3_CODEC_IDS.length)
+    expect(new Set(CIPHERSTASH_V3_CODEC_IDS).size).toBe(
+      CIPHERSTASH_V3_CODEC_IDS.length,
+    )
   })
 
   it('v3 and v2 codec-id sets are disjoint', () => {
@@ -32,19 +34,37 @@ describe('constants-v3', () => {
   })
 
   it('guard narrows only v3 ids', () => {
-    expect(isCipherstashV3CodecId('cipherstash/eql-v3/eql_v3_text_eq@1')).toBe(true)
+    expect(isCipherstashV3CodecId('cipherstash/eql-v3/eql_v3_text_eq@1')).toBe(
+      true,
+    )
     expect(isCipherstashV3CodecId('cipherstash/string@1')).toBe(false)
     // GA registry keys are eql_v3_*-prefixed; the un-prefixed form is NOT an id.
     expect(isCipherstashV3CodecId('cipherstash/eql-v3/text_eq@1')).toBe(false)
-    expect(CIPHERSTASH_V3_CODEC_ID_SET.has('cipherstash/eql-v3/eql_v3_text_eq@1')).toBe(true)
+    expect(
+      CIPHERSTASH_V3_CODEC_ID_SET.has('cipherstash/eql-v3/eql_v3_text_eq@1'),
+    ).toBe(true)
   })
 
   it('derives cipherstash-namespaced traits from capabilities', () => {
     expect(
-      [...v3TraitsForCapabilities({ equality: true, orderAndRange: true, freeTextSearch: true })].sort(),
-    ).toEqual(['cipherstash:equality', 'cipherstash:free-text-search', 'cipherstash:order-and-range'])
+      [
+        ...v3TraitsForCapabilities({
+          equality: true,
+          orderAndRange: true,
+          freeTextSearch: true,
+        }),
+      ].sort(),
+    ).toEqual([
+      'cipherstash:equality',
+      'cipherstash:free-text-search',
+      'cipherstash:order-and-range',
+    ])
     expect(
-      v3TraitsForCapabilities({ equality: false, orderAndRange: false, freeTextSearch: false }),
+      v3TraitsForCapabilities({
+        equality: false,
+        orderAndRange: false,
+        freeTextSearch: false,
+      }),
     ).toEqual([])
     expect(
       v3TraitsForCapabilities({
@@ -57,12 +77,18 @@ describe('constants-v3', () => {
   })
 
   it('pins the migration name + invariant', () => {
-    expect(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).toBe('20260601T0100_install_eql_v3_bundle')
-    expect(CIPHERSTASH_V3_INVARIANTS.installBundle).toBe('cipherstash:install-eql-v3-bundle-v1')
+    expect(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).toBe(
+      '20260601T0100_install_eql_v3_bundle',
+    )
+    expect(CIPHERSTASH_V3_INVARIANTS.installBundle).toBe(
+      'cipherstash:install-eql-v3-bundle-v1',
+    )
   })
 
   it('v3 extension identity is distinct from v2 (decision 1b — separate entry points)', () => {
     expect(CIPHERSTASH_V3_SPACE_ID).not.toBe(CIPHERSTASH_SPACE_ID)
-    expect(CIPHERSTASH_V3_EXTENSION_VERSION).not.toBe(CIPHERSTASH_EXTENSION_VERSION)
+    expect(CIPHERSTASH_V3_EXTENSION_VERSION).not.toBe(
+      CIPHERSTASH_EXTENSION_VERSION,
+    )
   })
 })

From c91f63e909f775846a9fa911c675f8e9853294bb Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 13:02:56 -0600
Subject: [PATCH 04/21] feat(prisma-next): v3 plain-JSONB cell codecs +
 EncryptedNumber envelope

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/src/v3/barrel.ts         |  12 +
 .../prisma-next/src/v3/codec-runtime-v3.ts    | 276 ++++++++++++++++++
 .../prisma-next/src/v3/envelope-number.ts     |  63 ++++
 packages/prisma-next/src/v3/wire-v3.ts        |  43 +++
 .../test/v3/codec-runtime-v3.test.ts          | 248 ++++++++++++++++
 .../test/v3/envelope-number.test.ts           | 135 +++++++++
 packages/prisma-next/test/v3/wire-v3.test.ts  |  45 +++
 7 files changed, 822 insertions(+)
 create mode 100644 packages/prisma-next/src/v3/barrel.ts
 create mode 100644 packages/prisma-next/src/v3/codec-runtime-v3.ts
 create mode 100644 packages/prisma-next/src/v3/envelope-number.ts
 create mode 100644 packages/prisma-next/src/v3/wire-v3.ts
 create mode 100644 packages/prisma-next/test/v3/codec-runtime-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/envelope-number.test.ts
 create mode 100644 packages/prisma-next/test/v3/wire-v3.test.ts

diff --git a/packages/prisma-next/src/v3/barrel.ts b/packages/prisma-next/src/v3/barrel.ts
new file mode 100644
index 00000000..7f1f49b1
--- /dev/null
+++ b/packages/prisma-next/src/v3/barrel.ts
@@ -0,0 +1,12 @@
+/**
+ * v3 user-facing value types, surfaced through the v3 subtree.
+ * Re-exports the version-neutral envelope classes (including
+ * `EncryptedJson` — the json domain is a first-class v3 domain) plus the
+ * v3-only `EncryptedNumber`. Pulls in NO v2 wire/codec code.
+ */
+export { EncryptedBigInt } from '../execution/envelope-bigint'
+export { EncryptedBoolean } from '../execution/envelope-boolean'
+export { EncryptedDate } from '../execution/envelope-date'
+export { EncryptedJson } from '../execution/envelope-json'
+export { EncryptedString } from '../execution/envelope-string'
+export { EncryptedNumber } from './envelope-number'
diff --git a/packages/prisma-next/src/v3/codec-runtime-v3.ts b/packages/prisma-next/src/v3/codec-runtime-v3.ts
new file mode 100644
index 00000000..fc1e8268
--- /dev/null
+++ b/packages/prisma-next/src/v3/codec-runtime-v3.ts
@@ -0,0 +1,276 @@
+/**
+ * v3 runtime codecs — one `RuntimeParameterizedCodecDescriptor` per
+ * catalog domain, derived from `V3_DOMAIN_META_BY_CODEC_ID` (never
+ * hand-listed). Parallel to the v2 `../execution/codec-runtime.ts` +
+ * `../execution/parameterized.ts` pair, with three deliberate
+ * differences:
+ *
+ *   - **Wire**: plain JSONB (`./wire-v3`), never the v2
+ *     `eql_v2_encrypted` composite literal. This module MUST NOT import
+ *     the v2 codec/wire (`encodeEqlV2EncryptedWire`), the v2
+ *     codec-runtime, or the v2 bulk-encrypt middleware.
+ *   - **Native type**: each descriptor targets its concrete
+ *     `public.eql_v3_*` domain (v2's six codecs all share one
+ *     `eql_v2_encrypted` composite type).
+ *   - **Traits**: derived per-domain from the catalog's query
+ *     capabilities via `v3TraitsForCapabilities` — the capability set is
+ *     intrinsic to the domain, not a per-column authoring option.
+ *
+ * Params shape matches the static `typeParams` block that v3 authoring
+ * emits (`contract-authoring.ts`): `{ castAs, capabilities }`. The codec
+ * runtime is stateless across params (encode reads ciphertext from the
+ * handle; decode constructs the per-castAs envelope), so the factory
+ * returns one shared codec per domain, mirroring v2 / pgvector.
+ */
+
+import type { JsonValue } from '@prisma-next/contract/types'
+import {
+  type AnyCodecDescriptor,
+  CodecImpl,
+  type CodecInstanceContext,
+  type CodecTrait,
+} from '@prisma-next/framework-components/codec'
+import { runtimeError } from '@prisma-next/framework-components/runtime'
+import type { SqlCodecCallContext } from '@prisma-next/sql-relational-core/ast'
+import type { RuntimeParameterizedCodecDescriptor } from '@prisma-next/sql-runtime'
+import { type as arktype } from 'arktype'
+import type { EncryptedEnvelopeBase } from '../execution/envelope-base'
+import { EncryptedBigInt } from '../execution/envelope-bigint'
+import { EncryptedBoolean } from '../execution/envelope-boolean'
+import { EncryptedDate } from '../execution/envelope-date'
+import { EncryptedJson } from '../execution/envelope-json'
+import { EncryptedString } from '../execution/envelope-string'
+import type { CipherstashSdk } from '../execution/sdk'
+import {
+  isCipherstashV3CodecId,
+  v3TraitsForCapabilities,
+} from '../extension-metadata/constants-v3'
+import {
+  envelopeTypeNameForCastAs,
+  V3_DOMAIN_META_BY_CODEC_ID,
+  type V3CastAs,
+  type V3DomainMeta,
+} from './catalog'
+import { EncryptedNumber } from './envelope-number'
+import { v3FromDriver, v3ToDriver } from './wire-v3'
+
+/**
+ * Per-domain params emitted by v3 authoring as a static `typeParams`
+ * block. Purely descriptive — the runtime codec ignores them (the
+ * capability set already determined the descriptor's traits at
+ * derivation time).
+ */
+export interface CipherstashV3CodecParams {
+  readonly castAs: string
+  readonly capabilities: object
+}
+
+export const cipherstashV3ParamsSchema = arktype({
+  castAs: 'string',
+  capabilities: 'object',
+})
+
+type FromInternal = (args: {
+  readonly ciphertext: unknown
+  readonly table: string
+  readonly column: string
+  readonly sdk: CipherstashSdk
+}) => EncryptedEnvelopeBase<unknown>
+
+/**
+ * Map a domain's `castAs` to its envelope `fromInternal` factory. Total
+ * over `V3CastAs` — a new castAs kind fails to compile here. The
+ * `date`/`timestamp` pair shares `EncryptedDate`; `json` reuses the
+ * version-neutral `EncryptedJson` envelope class.
+ */
+function fromInternalForCastAs(castAs: V3CastAs): FromInternal {
+  switch (castAs) {
+    case 'string':
+      return EncryptedString.fromInternal
+    case 'number':
+      return EncryptedNumber.fromInternal
+    case 'bigint':
+      return EncryptedBigInt.fromInternal
+    case 'date':
+    case 'timestamp':
+      return EncryptedDate.fromInternal
+    case 'boolean':
+      return EncryptedBoolean.fromInternal
+    case 'json':
+      return EncryptedJson.fromInternal
+  }
+}
+
+/**
+ * `CodecDescriptor.traits` is typed against the framework's closed
+ * `CodecTrait` union; the cipherstash traits live in the
+ * extension-private `cipherstash:` namespace so trait-gated framework
+ * built-ins (e.g. `eq` → SQL `=`) can never attach to encrypted
+ * columns. Framework 0.14 treats traits as opaque strings at runtime;
+ * the assertion is a type-level adapter only — same pattern (and full
+ * rationale) as v2's `CIPHERSTASH_CODEC_TRAITS` in
+ * `../extension-metadata/constants.ts`.
+ */
+function v3CodecTraits(meta: V3DomainMeta): readonly CodecTrait[] {
+  return v3TraitsForCapabilities(meta.capabilities) as readonly CodecTrait[]
+}
+
+export class CipherstashV3CellCodec<
+  E extends EncryptedEnvelopeBase<unknown>,
+> extends CodecImpl<string, readonly CodecTrait[], unknown, E> {
+  readonly #sdk: CipherstashSdk
+  readonly #fromInternal: FromInternal
+  readonly #typeName: string
+
+  constructor(
+    descriptor: AnyCodecDescriptor,
+    sdk: CipherstashSdk,
+    typeName: string,
+    fromInternal: FromInternal,
+  ) {
+    super(descriptor)
+    this.#sdk = sdk
+    this.#typeName = typeName
+    this.#fromInternal = fromInternal
+  }
+
+  async encode(value: E, _ctx: SqlCodecCallContext): Promise<unknown> {
+    // Two-pass write path (same contract as v2, plain-JSONB wire): the
+    // v3 bulk-encrypt middleware replaces the param with the JSONB text
+    // before the driver reads it — pass a pre-serialised string through.
+    // If we still hold an envelope, serialise its stamped ciphertext, or
+    // return the envelope itself as the pre-encrypt sentinel.
+    if (typeof value === 'string') {
+      return value
+    }
+    if (value === null || value === undefined) {
+      return value
+    }
+    const handle = value.expose()
+    if (handle.ciphertext === undefined) {
+      return value
+    }
+    return v3ToDriver(handle.ciphertext)
+  }
+
+  async decode(wire: unknown, ctx: SqlCodecCallContext): Promise<E> {
+    const column = ctx.column
+    if (!column) {
+      throw runtimeError(
+        'RUNTIME.DECODE_FAILED',
+        `cipherstash ${this.descriptor.codecId}: decode requires the projected-column routing context that the SQL runtime populates ` +
+          'for projected columns. The cell being decoded came from an aggregate, computed expression, or other unrouted source. ' +
+          'cipherstash codecs need a stable `(table, column)` routing key for envelope construction and bulk-decrypt grouping; ' +
+          'project the underlying encrypted column directly instead of through an aggregate.',
+        {
+          codecId: this.descriptor.codecId,
+          reason: 'cipherstash-v3-decode-column-context-missing',
+        },
+      )
+    }
+    // The per-domain `fromInternal` returns the base type; each codec is
+    // constructed with the factory matching its domain's castAs, so the
+    // narrow to `E` holds by construction.
+    return this.#fromInternal({
+      ciphertext: v3FromDriver(wire as string | object | null | undefined),
+      table: column.table,
+      column: column.name,
+      sdk: this.#sdk,
+    }) as E
+  }
+
+  encodeJson(_value: E): JsonValue {
+    const marker = `$${this.#typeName.charAt(0).toLowerCase()}${this.#typeName.slice(1)}`
+    return { [marker]: '<opaque>' } as JsonValue
+  }
+
+  decodeJson(_json: JsonValue): E {
+    throw new Error(
+      'cipherstash v3 codec: decodeJson is not supported; envelopes do not round-trip through JSON.',
+    )
+  }
+}
+
+/**
+ * Auxiliary descriptor for the `CodecImpl` base class — carries truthful
+ * metadata (codecId, traits, targetTypes, meta, renderOutputType) for
+ * readers that proxy through `codec.descriptor`, with a throwing
+ * `factory` stub: production resolution goes through the parameterized
+ * descriptors below, never `codec.descriptor.factory`. Same shape (and
+ * circularity rationale) as v2's `makeAuxiliaryDescriptor` in
+ * `../execution/cell-codec-factory.ts`.
+ */
+function makeV3AuxiliaryDescriptor(
+  codecId: string,
+  meta: V3DomainMeta,
+  typeName: string,
+): AnyCodecDescriptor {
+  return {
+    codecId,
+    traits: v3CodecTraits(meta),
+    targetTypes: [meta.nativeType],
+    meta: { db: { sql: { postgres: { nativeType: meta.nativeType } } } },
+    paramsSchema: cipherstashV3ParamsSchema,
+    isParameterized: true,
+    renderOutputType: () => typeName,
+    factory: () => () => {
+      throw new Error(
+        'cipherstash v3 codec: auxiliary descriptor factory was invoked. ' +
+          'This is a programming error — v3 codecs are resolved through the ' +
+          'parameterized descriptors returned by `createV3CodecDescriptors(sdk)`, ' +
+          'not through `codec.descriptor.factory`.',
+      )
+    },
+  }
+}
+
+function makeV3Descriptor(
+  sdk: CipherstashSdk,
+  codecId: string,
+  meta: V3DomainMeta,
+): RuntimeParameterizedCodecDescriptor<CipherstashV3CodecParams> {
+  const typeName = envelopeTypeNameForCastAs(meta.castAs)
+  const codec = new CipherstashV3CellCodec<EncryptedEnvelopeBase<unknown>>(
+    makeV3AuxiliaryDescriptor(codecId, meta, typeName),
+    sdk,
+    typeName,
+    fromInternalForCastAs(meta.castAs),
+  )
+  return {
+    codecId,
+    traits: v3CodecTraits(meta),
+    targetTypes: [meta.nativeType],
+    meta: { db: { sql: { postgres: { nativeType: meta.nativeType } } } },
+    paramsSchema: cipherstashV3ParamsSchema,
+    isParameterized: true as const,
+    renderOutputType: (_params: CipherstashV3CodecParams) => typeName,
+    factory:
+      (_params: CipherstashV3CodecParams) => (_ctx: CodecInstanceContext) =>
+        codec,
+  }
+}
+
+/**
+ * One runtime descriptor per catalog domain (all 40, including the
+ * authoring-unexposed `*_ord_ore` variants — the codec layer must decode
+ * whatever the catalog can name), closed over `sdk` so multi-tenant
+ * deployments can compose multiple cipherstash extensions side-by-side
+ * without cross-talk.
+ */
+export function createV3CodecDescriptors(
+  sdk: CipherstashSdk,
+): ReadonlyArray<
+  RuntimeParameterizedCodecDescriptor<CipherstashV3CodecParams>
+> {
+  return [...V3_DOMAIN_META_BY_CODEC_ID.entries()].map(([codecId, meta]) => {
+    // The catalog and the pinned codec-id union are compile-time-locked
+    // to each other (see constants-v3.ts); a mismatch here means the
+    // derivation itself drifted — fail loudly.
+    if (!isCipherstashV3CodecId(codecId)) {
+      throw new Error(
+        `cipherstash v3 codec: catalog produced unpinned codec id "${codecId}" — update CIPHERSTASH_V3_CODEC_IDS.`,
+      )
+    }
+    return makeV3Descriptor(sdk, codecId, meta)
+  })
+}
diff --git a/packages/prisma-next/src/v3/envelope-number.ts b/packages/prisma-next/src/v3/envelope-number.ts
new file mode 100644
index 00000000..445cfec8
--- /dev/null
+++ b/packages/prisma-next/src/v3/envelope-number.ts
@@ -0,0 +1,63 @@
+/**
+ * `EncryptedNumber` envelope — the user-facing input/output type for the
+ * v3 number-family codecs (`cipherstash/eql-v3/eql_v3_integer*@1`,
+ * `..._smallint*`, `..._numeric*`, `..._real*`, `..._double*`). Concrete
+ * subclass of {@link EncryptedEnvelopeBase} parameterised on `number`.
+ *
+ * A SIBLING of the v2 `EncryptedDouble` — NOT a subclass or alias. Its
+ * distinct `typeName` drives the `$encryptedNumber` placeholder marker;
+ * keeping the class separate prevents `value instanceof EncryptedNumber`
+ * from matching a v2 `EncryptedDouble` (a cross-version leak). Every v3
+ * number-castAs domain (integer / smallint / numeric / real / double)
+ * renders as `EncryptedNumber`.
+ *
+ * No `parseDecryptedValue` override is needed: the SDK's polymorphic
+ * `bulkDecrypt` / single-cell `decrypt` already returns numeric
+ * plaintexts as `number`; the base's default identity cast suffices.
+ */
+
+import {
+  EncryptedEnvelopeBase,
+  type EncryptedEnvelopeFromInternalArgs,
+  type EncryptedEnvelopeHandle,
+} from '../execution/envelope-base'
+
+export type EncryptedNumberHandle = EncryptedEnvelopeHandle<number>
+
+export type EncryptedNumberFromInternalArgs = EncryptedEnvelopeFromInternalArgs
+
+export class EncryptedNumber extends EncryptedEnvelopeBase<number> {
+  protected override get typeName(): string {
+    return 'EncryptedNumber'
+  }
+
+  /**
+   * Construct a write-side envelope from a plaintext number. Bulk-encrypt
+   * middleware populates the handle's ciphertext slot before the codec
+   * encodes the envelope to wire format.
+   */
+  static from(plaintext: number): EncryptedNumber {
+    return new EncryptedNumber({
+      plaintext,
+      ciphertext: undefined,
+      table: undefined,
+      column: undefined,
+      sdk: undefined,
+    })
+  }
+
+  /**
+   * Construct a read-side envelope from a wire ciphertext + the column
+   * identity + the SDK used to decrypt the cell. Called from the codec
+   * `decode` body.
+   */
+  static fromInternal(args: EncryptedNumberFromInternalArgs): EncryptedNumber {
+    return new EncryptedNumber({
+      plaintext: undefined,
+      ciphertext: args.ciphertext,
+      table: args.table,
+      column: args.column,
+      sdk: args.sdk,
+    })
+  }
+}
diff --git a/packages/prisma-next/src/v3/wire-v3.ts b/packages/prisma-next/src/v3/wire-v3.ts
new file mode 100644
index 00000000..0abb011c
--- /dev/null
+++ b/packages/prisma-next/src/v3/wire-v3.ts
@@ -0,0 +1,43 @@
+/**
+ * v3 wire format: plain JSONB.
+ *
+ * v3 columns are `CREATE DOMAIN public.eql_v3_* AS jsonb ...`, so a cell
+ * serialises as plain JSONB text — deliberately distinct from v2's
+ * `eql_v2_encrypted` composite-literal wire (`("...")`,
+ * see `../execution/cell-codec-factory.ts`), which this module MUST NOT
+ * import or reproduce. Encode is `JSON.stringify` of the EQL payload;
+ * decode is `JSON.parse` for text wires with object passthrough for pg
+ * clients that pre-parse jsonb cells.
+ *
+ * The original plan intended these helpers to be a thin re-export of a
+ * shared, framework-neutral codec lifted to `@cipherstash/stack/eql/v3`.
+ * That lift has not happened (the stack's v3 barrel exports only the
+ * authoring DSL), so the implementation lives here; if/when the shared
+ * primitive lands, replace the bodies below with a re-export.
+ */
+
+// `bigintSafeReplacer` is LOAD-BEARING and must not be dropped: a
+// well-formed envelope never carries a bigint (bigint plaintext is
+// encrypted to ciphertext strings first), but a malformed envelope with
+// a stray bigint would otherwise throw
+// `TypeError: Do not know how to serialize a BigInt`.
+function bigintSafeReplacer(_key: string, value: unknown): unknown {
+  return typeof value === 'bigint' ? value.toString() : value
+}
+
+/** Serialise an EQL payload to plain JSONB text; `null`/`undefined` → `null`. */
+export function v3ToDriver(value: unknown): string | null {
+  if (value === null || value === undefined) return null
+  return JSON.stringify(value, bigintSafeReplacer)
+}
+
+/**
+ * Parse a JSONB wire back to the EQL payload. Text wires are
+ * `JSON.parse`d; objects (drivers that pre-parse jsonb) pass through;
+ * `null`/`undefined` are preserved as-is.
+ */
+export function v3FromDriver<T>(value: string | object | null | undefined): T {
+  if (value === null || value === undefined) return value as T
+  if (typeof value === 'object') return value as T
+  return JSON.parse(value) as T
+}
diff --git a/packages/prisma-next/test/v3/codec-runtime-v3.test.ts b/packages/prisma-next/test/v3/codec-runtime-v3.test.ts
new file mode 100644
index 00000000..d6affd61
--- /dev/null
+++ b/packages/prisma-next/test/v3/codec-runtime-v3.test.ts
@@ -0,0 +1,248 @@
+/**
+ * Behavioural tests for the v3 cell codec + per-domain runtime
+ * descriptors.
+ *
+ * Pins:
+ *   - one descriptor per catalog domain, keyed by the GA codec id
+ *     (`cipherstash/eql-v3/eql_v3_*@1`) with the concrete
+ *     `public.eql_v3_*` domain as native/target type — NOT the shared
+ *     v2 `eql_v2_encrypted` composite;
+ *   - traits derived from the domain's query capabilities
+ *     (`v3TraitsForCapabilities`), including `cipherstash:searchable-json`
+ *     for the json domain;
+ *   - per-castAs envelope rendering (`EncryptedNumber` for number
+ *     domains, `EncryptedBigInt` for bigint, `EncryptedJson` for json);
+ *   - encode/decode over the plain-JSONB v3 wire, never the v2
+ *     composite literal.
+ */
+
+import type { CodecInstanceContext } from '@prisma-next/framework-components/codec'
+import type { SqlCodecCallContext } from '@prisma-next/sql-relational-core/ast'
+import { describe, expect, it, vi } from 'vitest'
+import { EncryptedBigInt } from '../../src/execution/envelope-bigint'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import type { CipherstashSdk } from '../../src/execution/sdk'
+import { V3_CODEC_IDS } from '../../src/v3/catalog'
+import { createV3CodecDescriptors } from '../../src/v3/codec-runtime-v3'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+
+const emptySdk = (): CipherstashSdk => ({
+  decrypt: vi.fn(),
+  bulkEncrypt: vi.fn(),
+  bulkDecrypt: vi.fn(),
+})
+
+const instanceCtx = {} as CodecInstanceContext
+
+function codecFor(
+  descriptors: ReturnType<typeof createV3CodecDescriptors>,
+  codecId: string,
+) {
+  const descriptor = descriptors.find((d) => d.codecId === codecId)
+  if (!descriptor) throw new Error(`no descriptor for ${codecId}`)
+  return descriptor.factory({
+    castAs: 'string',
+    capabilities: {},
+  })(instanceCtx)
+}
+
+describe('createV3CodecDescriptors — descriptor metadata', () => {
+  it('emits one descriptor per catalog domain, keyed by the GA codec id set', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    expect(ds.map((d) => d.codecId).sort()).toEqual([...V3_CODEC_IDS].sort())
+  })
+
+  it('native type = the concrete public.eql_v3_* domain (never eql_v2_encrypted)', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    const textSearch = ds.find(
+      (d) => d.codecId === 'cipherstash/eql-v3/eql_v3_text_search@1',
+    )
+    expect(textSearch).toBeDefined()
+    expect(textSearch?.targetTypes).toEqual(['public.eql_v3_text_search'])
+    expect(textSearch?.meta).toEqual({
+      db: { sql: { postgres: { nativeType: 'public.eql_v3_text_search' } } },
+    })
+    expect(textSearch?.isParameterized).toBe(true)
+    for (const d of ds) {
+      expect(d.targetTypes).toHaveLength(1)
+      expect(d.targetTypes[0]).toMatch(/^public\.eql_v3_/)
+      expect(d.targetTypes[0]).not.toBe('eql_v2_encrypted')
+    }
+  })
+
+  it('storage-only eql_v3_boolean declares no traits; eql_v3_text_search declares all three', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    expect(
+      ds.find((d) => d.codecId === 'cipherstash/eql-v3/eql_v3_boolean@1')
+        ?.traits,
+    ).toEqual([])
+    expect(
+      [
+        ...(ds.find(
+          (d) => d.codecId === 'cipherstash/eql-v3/eql_v3_text_search@1',
+        )?.traits ?? []),
+      ].sort(),
+    ).toEqual([
+      'cipherstash:equality',
+      'cipherstash:free-text-search',
+      'cipherstash:order-and-range',
+    ])
+  })
+
+  it('eql_v3_json declares only the searchable-json trait', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    expect(
+      ds.find((d) => d.codecId === 'cipherstash/eql-v3/eql_v3_json@1')?.traits,
+    ).toEqual(['cipherstash:searchable-json'])
+  })
+
+  it('renderOutputType maps castAs to the envelope class name', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    const render = (codecId: string) =>
+      ds
+        .find((d) => d.codecId === codecId)
+        ?.renderOutputType?.({ castAs: 'string', capabilities: {} })
+    expect(render('cipherstash/eql-v3/eql_v3_text_search@1')).toBe(
+      'EncryptedString',
+    )
+    expect(render('cipherstash/eql-v3/eql_v3_integer_ord@1')).toBe(
+      'EncryptedNumber',
+    )
+    expect(render('cipherstash/eql-v3/eql_v3_bigint_ord@1')).toBe(
+      'EncryptedBigInt',
+    )
+    expect(render('cipherstash/eql-v3/eql_v3_date_eq@1')).toBe('EncryptedDate')
+    expect(render('cipherstash/eql-v3/eql_v3_timestamp_ord@1')).toBe(
+      'EncryptedDate',
+    )
+    expect(render('cipherstash/eql-v3/eql_v3_boolean@1')).toBe(
+      'EncryptedBoolean',
+    )
+    expect(render('cipherstash/eql-v3/eql_v3_json@1')).toBe('EncryptedJson')
+  })
+})
+
+describe('CipherstashV3CellCodec — encode (plain JSONB)', () => {
+  const callCtx = {} as SqlCodecCallContext
+
+  it("serialises an envelope's ciphertext to plain JSONB text", async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    const envelope = EncryptedString.fromInternal({
+      ciphertext: { c: 'abc' },
+      table: 'users',
+      column: 'email',
+      sdk: emptySdk(),
+    })
+    const encoded = await codec.encode(envelope, callCtx)
+    expect(encoded).toBe('{"c":"abc"}')
+  })
+
+  it('never emits the v2 composite literal shape', async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    const envelope = EncryptedString.fromInternal({
+      ciphertext: { c: 'with "quotes"' },
+      table: 'users',
+      column: 'email',
+      sdk: emptySdk(),
+    })
+    const encoded = await codec.encode(envelope, callCtx)
+    // Plain JSON text — not the v2 composite literal `("...")` with its
+    // doubled-quote escaping.
+    expect(encoded).toBe(JSON.stringify({ c: 'with "quotes"' }))
+    expect(encoded as string).not.toMatch(/^\(/)
+  })
+
+  it('passes a pre-serialised JSONB string through unchanged (middleware two-pass)', async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    expect(await codec.encode('{"c":"enc"}', callCtx)).toBe('{"c":"enc"}')
+  })
+
+  it('returns the envelope unchanged when it has no ciphertext yet (pre-encrypt sentinel)', async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    const preEncrypt = EncryptedString.from('plaintext')
+    expect(await codec.encode(preEncrypt, callCtx)).toBe(preEncrypt)
+  })
+})
+
+describe('CipherstashV3CellCodec — decode', () => {
+  const routedCtx = (table: string, name: string) =>
+    ({ column: { table, name } }) as SqlCodecCallContext
+
+  it('parses JSONB text and constructs the per-castAs envelope with routing context', async () => {
+    const sdk = emptySdk()
+    const codec = codecFor(
+      createV3CodecDescriptors(sdk),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    const decoded = await codec.decode(
+      '{"c":"abc"}',
+      routedCtx('users', 'email'),
+    )
+    expect(decoded).toBeInstanceOf(EncryptedString)
+    const handle = (decoded as EncryptedString).expose()
+    expect(handle.ciphertext).toEqual({ c: 'abc' })
+    expect(handle.table).toBe('users')
+    expect(handle.column).toBe('email')
+    expect(handle.sdk).toBe(sdk)
+  })
+
+  it('passes driver-pre-parsed objects through without re-parsing', async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_integer_ord@1',
+    )
+    const decoded = await codec.decode({ c: 'abc' }, routedCtx('m', 'v'))
+    expect(decoded).toBeInstanceOf(EncryptedNumber)
+    expect((decoded as EncryptedNumber).expose().ciphertext).toEqual({
+      c: 'abc',
+    })
+  })
+
+  it('constructs EncryptedBigInt for bigint domains and EncryptedJson for the json domain', async () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    const bigintDecoded = await codecFor(
+      ds,
+      'cipherstash/eql-v3/eql_v3_bigint_eq@1',
+    ).decode('{"c":"x"}', routedCtx('t', 'c'))
+    expect(bigintDecoded).toBeInstanceOf(EncryptedBigInt)
+    const jsonDecoded = await codecFor(
+      ds,
+      'cipherstash/eql-v3/eql_v3_json@1',
+    ).decode('{"c":"x"}', routedCtx('t', 'c'))
+    expect(jsonDecoded).toBeInstanceOf(EncryptedJson)
+  })
+
+  it('throws a routed error when the column routing context is missing', async () => {
+    const codec = codecFor(
+      createV3CodecDescriptors(emptySdk()),
+      'cipherstash/eql-v3/eql_v3_text_eq@1',
+    )
+    await expect(
+      codec.decode('{"c":"abc"}', {} as SqlCodecCallContext),
+    ).rejects.toThrow(/routing context/)
+  })
+})
+
+describe('CipherstashV3CellCodec — JSON plane', () => {
+  it('encodeJson renders the per-type opaque marker; decodeJson throws', () => {
+    const ds = createV3CodecDescriptors(emptySdk())
+    const codec = codecFor(ds, 'cipherstash/eql-v3/eql_v3_integer_ord@1')
+    expect(codec.encodeJson(EncryptedNumber.from(1))).toEqual({
+      $encryptedNumber: '<opaque>',
+    })
+    expect(() => codec.decodeJson({})).toThrow(/decodeJson/)
+  })
+})
diff --git a/packages/prisma-next/test/v3/envelope-number.test.ts b/packages/prisma-next/test/v3/envelope-number.test.ts
new file mode 100644
index 00000000..950e88e2
--- /dev/null
+++ b/packages/prisma-next/test/v3/envelope-number.test.ts
@@ -0,0 +1,135 @@
+/**
+ * Behavioural tests for the v3 `EncryptedNumber` envelope.
+ *
+ * Mirrors `test/envelope-double.test.ts` (subclass surface, decrypt
+ * round-trip, the four non-`toJSON` redaction overrides, the
+ * `JSON.stringify` placeholder shape) and additionally pins the
+ * sibling relationship with the v2 `EncryptedDouble`: the two classes
+ * must not satisfy each other's `instanceof` (a cross-version leak).
+ */
+
+import { inspect } from 'node:util'
+import { describe, expect, it, vi } from 'vitest'
+import { EncryptedEnvelopeBase } from '../../src/execution/envelope-base'
+import { EncryptedDouble } from '../../src/execution/envelope-double'
+import type { CipherstashSdk } from '../../src/execution/sdk'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+
+function emptySdk(): CipherstashSdk {
+  return {
+    decrypt: vi.fn(),
+    bulkEncrypt: vi.fn(),
+    bulkDecrypt: vi.fn(),
+  }
+}
+
+describe('EncryptedNumber — sibling of EncryptedDouble', () => {
+  it('is a distinct sibling of EncryptedDouble (no cross-instanceof leak)', () => {
+    const n = EncryptedNumber.from(42)
+    expect(n).toBeInstanceOf(EncryptedNumber)
+    expect(n instanceof EncryptedDouble).toBe(false)
+    expect(EncryptedDouble.from(42) instanceof EncryptedNumber).toBe(false)
+  })
+
+  it('renders the $encryptedNumber placeholder marker (distinct typeName)', () => {
+    expect(JSON.stringify(EncryptedNumber.from(7))).toBe(
+      '{"$encryptedNumber":"<opaque>"}',
+    )
+  })
+})
+
+describe('EncryptedNumber.from(plaintext)', () => {
+  it('returns an EncryptedNumber instance that extends EncryptedEnvelopeBase', () => {
+    const envelope = EncryptedNumber.from(3.14)
+    expect(envelope).toBeInstanceOf(EncryptedNumber)
+    expect(envelope).toBeInstanceOf(EncryptedEnvelopeBase)
+  })
+
+  it('redacts and round-trips plaintext via decrypt() fast path', async () => {
+    const envelope = EncryptedNumber.from(3.14)
+    expect(String(envelope)).toBe('[REDACTED]')
+    await expect(envelope.decrypt()).resolves.toBe(3.14)
+  })
+
+  it('preserves negative and zero values without coercion', async () => {
+    await expect(EncryptedNumber.from(-1.5).decrypt()).resolves.toBe(-1.5)
+    await expect(EncryptedNumber.from(0).decrypt()).resolves.toBe(0)
+  })
+})
+
+describe('EncryptedNumber.fromInternal(...) — read-side round-trip', () => {
+  it('decrypt({signal}) calls the SDK single-cell decrypt and returns the numeric plaintext', async () => {
+    const ciphertext = { c: 'cipher', i: { t: 'metric', c: 'value' } }
+    const decryptMock = vi.fn().mockResolvedValue(42.5)
+    const sdk: CipherstashSdk = {
+      decrypt: decryptMock,
+      bulkEncrypt: vi.fn(),
+      bulkDecrypt: vi.fn(),
+    }
+
+    const envelope = EncryptedNumber.fromInternal({
+      ciphertext,
+      table: 'metric',
+      column: 'value',
+      sdk,
+    })
+
+    const ac = new AbortController()
+    const result = await envelope.decrypt({ signal: ac.signal })
+
+    expect(result).toBe(42.5)
+    expect(decryptMock).toHaveBeenCalledTimes(1)
+    expect(decryptMock.mock.calls[0]?.[0]).toMatchObject({
+      ciphertext,
+      table: 'metric',
+      column: 'value',
+      signal: ac.signal,
+    })
+  })
+
+  it('exposes the (table, column) routing context + SDK on the handle', () => {
+    const sdk = emptySdk()
+    const envelope = EncryptedNumber.fromInternal({
+      ciphertext: 'wire',
+      table: 'metric',
+      column: 'value',
+      sdk,
+    })
+    const handle = envelope.expose()
+    expect(handle.table).toBe('metric')
+    expect(handle.column).toBe('value')
+    expect(handle.sdk).toBe(sdk)
+    expect(handle.plaintext).toBeUndefined()
+  })
+})
+
+describe('EncryptedNumber — accidental-exposure overrides', () => {
+  it('toString() returns [REDACTED] regardless of plaintext value', () => {
+    expect(EncryptedNumber.from(42).toString()).toBe('[REDACTED]')
+  })
+
+  it('valueOf() returns [REDACTED]', () => {
+    expect(EncryptedNumber.from(42).valueOf()).toBe('[REDACTED]')
+  })
+
+  it('Symbol.toPrimitive returns [REDACTED] for template-literal coercion', () => {
+    const envelope = EncryptedNumber.from(42)
+    expect(`v=${envelope}`).toBe('v=[REDACTED]')
+  })
+
+  it('util.inspect returns [REDACTED]', () => {
+    const envelope = EncryptedNumber.from(42)
+    const inspected = inspect(envelope, {
+      depth: Number.POSITIVE_INFINITY,
+      getters: true,
+    })
+    expect(inspected).not.toContain('42')
+    expect(inspected).toContain('[REDACTED]')
+  })
+
+  it('JSON.stringify cannot leak plaintext', () => {
+    const envelope = EncryptedNumber.from(123.456789)
+    const json = JSON.stringify({ value: envelope })
+    expect(json).not.toContain('123.456789')
+  })
+})
diff --git a/packages/prisma-next/test/v3/wire-v3.test.ts b/packages/prisma-next/test/v3/wire-v3.test.ts
new file mode 100644
index 00000000..d66800ed
--- /dev/null
+++ b/packages/prisma-next/test/v3/wire-v3.test.ts
@@ -0,0 +1,45 @@
+/**
+ * Behavioural tests for the v3 wire format: plain JSONB, never the v2
+ * `eql_v2_encrypted` composite literal. v3 columns are
+ * `CREATE DOMAIN public.eql_v3_* AS jsonb ...`, so the wire is JSON
+ * text on the way in and JSON text (or a driver-pre-parsed object) on
+ * the way out.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { v3FromDriver, v3ToDriver } from '../../src/v3/wire-v3'
+
+describe('v3 wire (plain JSONB)', () => {
+  it('serialises to JSON text, never the v2 composite literal', () => {
+    expect(v3ToDriver({ a: 1 })).toBe('{"a":1}')
+    expect(v3ToDriver({ a: 1 })).not.toMatch(/^\(/)
+  })
+
+  it('null/undefined -> null', () => {
+    expect(v3ToDriver(null)).toBeNull()
+    expect(v3ToDriver(undefined)).toBeNull()
+  })
+
+  it('bigintSafeReplacer: a stray bigint in a malformed envelope serialises to its decimal string, not a throw', () => {
+    // A well-formed envelope never carries a bigint (bigint plaintext is
+    // encrypted to ciphertext strings first); this pins the defensive
+    // guard so the codec never throws "Do not know how to serialize a BigInt".
+    expect(v3ToDriver({ c: 10n })).toBe('{"c":"10"}')
+    expect(() => v3ToDriver({ c: 9007199254740993n })).not.toThrow()
+    expect(v3ToDriver({ c: 9007199254740993n })).toBe(
+      '{"c":"9007199254740993"}',
+    )
+  })
+
+  it('fromDriver parses text, passes objects through, preserves null/undefined', () => {
+    expect(v3FromDriver('{"a":1}')).toEqual({ a: 1 })
+    expect(v3FromDriver({ a: 1 } as object)).toEqual({ a: 1 })
+    expect(v3FromDriver(null)).toBeNull()
+    expect(v3FromDriver(undefined)).toBeUndefined()
+  })
+
+  it('fromDriver(toDriver(payload)) round-trips an EQL payload', () => {
+    const payload = { c: 'abc', i: { t: 'users', c: 'email' }, v: 2 }
+    expect(v3FromDriver(v3ToDriver(payload))).toEqual(payload)
+  })
+})

From d59764d3d8ae2e0d606ef90479c8606fc9434438 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 13:08:59 -0600
Subject: [PATCH 05/21] feat(prisma-next): v3 bulk-encrypt middleware
 (plain-JSONB payloads)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/middleware/bulk-encrypt.ts            |   9 +-
 .../prisma-next/src/v3/bulk-encrypt-v3.ts     | 155 ++++++++
 .../test/bulk-encrypt-middleware.helpers.ts   | 144 +++++++
 .../test/bulk-encrypt-middleware.test.ts      | 134 +------
 .../test/v3/bulk-encrypt-v3.test.ts           | 368 ++++++++++++++++++
 5 files changed, 684 insertions(+), 126 deletions(-)
 create mode 100644 packages/prisma-next/src/v3/bulk-encrypt-v3.ts
 create mode 100644 packages/prisma-next/test/bulk-encrypt-middleware.helpers.ts
 create mode 100644 packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts

diff --git a/packages/prisma-next/src/middleware/bulk-encrypt.ts b/packages/prisma-next/src/middleware/bulk-encrypt.ts
index 23143852..99236669 100644
--- a/packages/prisma-next/src/middleware/bulk-encrypt.ts
+++ b/packages/prisma-next/src/middleware/bulk-encrypt.ts
@@ -194,7 +194,14 @@ function collectTargets(
   return targets
 }
 
-function stampRoutingKeysFromAst(ast: AnyQueryAst | undefined): void {
+/**
+ * Walk a lowered `InsertAst` / `UpdateAst` and stamp `(table, column)`
+ * routing context onto every cipherstash envelope embedded in a
+ * `ParamRef`. Version-neutral: it touches only the shared envelope base
+ * and the AST — no wire/codec knowledge — so the v3 middleware
+ * (`../v3/bulk-encrypt-v3.ts`) reuses it rather than forking the walk.
+ */
+export function stampRoutingKeysFromAst(ast: AnyQueryAst | undefined): void {
   if (!ast) return
   switch (ast.kind) {
     case 'insert':
diff --git a/packages/prisma-next/src/v3/bulk-encrypt-v3.ts b/packages/prisma-next/src/v3/bulk-encrypt-v3.ts
new file mode 100644
index 00000000..9b96948a
--- /dev/null
+++ b/packages/prisma-next/src/v3/bulk-encrypt-v3.ts
@@ -0,0 +1,155 @@
+/**
+ * v3 bulk-encrypt middleware — the plain-JSONB twin of the v2
+ * `../middleware/bulk-encrypt.ts`. Same `beforeExecute` lifecycle and
+ * batching contract, with two deliberate differences:
+ *
+ *   - **Jurisdiction**: params are matched against the closed v3
+ *     codec-id set ({@link CIPHERSTASH_V3_CODEC_ID_SET}), never the v2
+ *     set — the two middlewares partition the param space by codec id,
+ *     so a plan whose params carry v2 codec ids is invisible here.
+ *   - **Wire**: the param slot is replaced with the plain JSONB text of
+ *     the EQL payload ({@link v3ToDriver} — v3 columns are PG domains
+ *     over `jsonb`), never the v2 `eql_v2_encrypted` composite literal.
+ *     This module MUST NOT import `encodeEqlV2EncryptedWire`.
+ *
+ * The `(table, column)` routing-key stamping is NOT forked: the AST walk
+ * is version-neutral (it touches only the shared envelope base) and is
+ * reused from the v2 module via the exported
+ * {@link stampRoutingKeysFromAst}.
+ *
+ * Everything else — one `sdk.bulkEncrypt` per `(table, column)` group,
+ * `setHandleCiphertext` stamping with plaintext retention, `ctx.signal`
+ * forwarding by identity plus the pre-flight abort check and the abort
+ * race, and the ciphertext-count diagnostic — mirrors the v2 middleware;
+ * see its module doc for the full lifecycle rationale.
+ */
+
+import type {
+  ParamRefHandle,
+  SqlParamRefMutator,
+} from '@prisma-next/sql-relational-core/middleware'
+import type { SqlMiddleware } from '@prisma-next/sql-runtime'
+import { ifDefined } from '@prisma-next/utils/defined'
+import {
+  checkCipherstashAborted,
+  raceCipherstashAbort,
+} from '../execution/abort'
+import {
+  EncryptedEnvelopeBase,
+  setHandleCiphertext,
+} from '../execution/envelope-base'
+import { markBulkEncryptMiddlewareRegistered } from '../execution/middleware-registry'
+import { type BulkEncryptTarget, groupByRoutingKey } from '../execution/routing'
+import type { CipherstashSdk } from '../execution/sdk'
+import { CIPHERSTASH_V3_CODEC_ID_SET } from '../extension-metadata/constants-v3'
+// Version-neutral AST routing-key stamping — reused, not the v2 encode path.
+import { stampRoutingKeysFromAst } from '../middleware/bulk-encrypt'
+import { v3ToDriver } from './wire-v3'
+
+/**
+ * Construct the v3 bulk-encrypt middleware. The returned middleware is
+ * stateless aside from the captured `sdk` reference; one instance per
+ * (v3) runtime extension is the expected pattern.
+ */
+export function bulkEncryptMiddlewareV3(sdk: CipherstashSdk): SqlMiddleware {
+  // Mark this sdk as wired up so the codec's `encode` can distinguish
+  // "happy path: middleware will run later and fill in the ciphertext"
+  // from "misconfig: this sdk has no middleware registered". See
+  // `../execution/middleware-registry.ts`.
+  markBulkEncryptMiddlewareRegistered(sdk)
+  return {
+    name: 'cipherstash.bulk-encrypt-v3',
+    familyId: 'sql',
+    async beforeExecute(plan, ctx, params) {
+      if (!params) {
+        return
+      }
+
+      stampRoutingKeysFromAst(plan.ast)
+
+      const targets = collectV3Targets(params)
+      if (targets.length === 0) {
+        return
+      }
+
+      const groups = groupByRoutingKey(targets)
+      for (const [groupKey, group] of groups) {
+        const first = group[0]
+        if (!first) continue
+        const routingKey = first.routingKey
+
+        checkCipherstashAborted(ctx.signal, 'bulk-encrypt')
+        const ciphertexts = await raceCipherstashAbort(
+          sdk.bulkEncrypt({
+            routingKey,
+            values: group.map((t) => t.plaintext),
+            ...ifDefined('signal', ctx.signal),
+          }),
+          ctx.signal,
+          'bulk-encrypt',
+        )
+
+        if (ciphertexts.length !== group.length) {
+          throw new Error(
+            `cipherstash v3 bulk-encrypt: SDK returned ${ciphertexts.length} ciphertexts ` +
+              `for routing key ${groupKey} but ${group.length} were requested.`,
+          )
+        }
+
+        // Replace each ParamRef's value with the plain JSONB text the
+        // pg driver can serialise directly (the envelope instance
+        // itself would fail at the driver boundary). The envelope's
+        // ciphertext slot is also stamped via `setHandleCiphertext`
+        // and its plaintext slot retained, so follow-on reuse of the
+        // same envelope skips the re-encrypt round-trip.
+        params.replaceValues(
+          group.map((t, i) => {
+            const ciphertext = ciphertexts[i]
+            setHandleCiphertext(t.envelope, ciphertext)
+            return {
+              ref: t.ref,
+              newValue: v3ToDriver(ciphertext),
+            }
+          }),
+        )
+      }
+    },
+  }
+}
+
+function collectV3Targets(
+  params: SqlParamRefMutator,
+): BulkEncryptTarget<ParamRefHandle<string | undefined>>[] {
+  const targets: BulkEncryptTarget<ParamRefHandle<string | undefined>>[] = []
+  for (const entry of params.entries()) {
+    if (
+      entry.codecId === undefined ||
+      !CIPHERSTASH_V3_CODEC_ID_SET.has(entry.codecId)
+    )
+      continue
+    const value = entry.value
+    if (!(value instanceof EncryptedEnvelopeBase)) continue
+    const handle = value.expose()
+    if (handle.plaintext === undefined) {
+      throw new Error(
+        'cipherstash v3 bulk-encrypt: encountered an envelope with no plaintext on the write path. ' +
+          'Use the relevant `Encrypted*.from(plaintext)` factory to construct write-side envelopes.',
+      )
+    }
+    if (handle.table === undefined || handle.column === undefined) {
+      throw new Error(
+        'cipherstash v3 bulk-encrypt: envelope reached the bulk-encrypt phase without a (table, column) ' +
+          "routing context. The middleware's AST walk only handles `InsertAst` and `UpdateAst`; " +
+          'cipherstash envelopes embedded in other plan shapes (e.g. raw SQL) must stamp routing ' +
+          'context explicitly via `setHandleRoutingKey` before execute.',
+      )
+    }
+    targets.push({
+      ref: entry.ref,
+      plaintext: handle.plaintext,
+      envelope: value,
+      routingKey: { table: handle.table, column: handle.column },
+    })
+  }
+  return targets
+}
diff --git a/packages/prisma-next/test/bulk-encrypt-middleware.helpers.ts b/packages/prisma-next/test/bulk-encrypt-middleware.helpers.ts
new file mode 100644
index 00000000..2ac3911b
--- /dev/null
+++ b/packages/prisma-next/test/bulk-encrypt-middleware.helpers.ts
@@ -0,0 +1,144 @@
+/**
+ * Shared harness for the bulk-encrypt middleware suites (v2
+ * `bulk-encrypt-middleware.test.ts` and v3 `v3/bulk-encrypt-v3.test.ts`).
+ * Version-neutral by construction: plan builders take the codec id to
+ * stamp on each `ParamRef` (defaulting to the v2 string codec id so
+ * existing v2 call sites read unchanged), and the mock SDK echoes
+ * whatever ciphertext shape the caller's `encryptImpl` produces.
+ */
+
+import type { Contract, PlanMeta } from '@prisma-next/contract/types'
+import type { SqlStorage } from '@prisma-next/sql-contract/types'
+import {
+  type ColumnRef,
+  InsertAst,
+  ParamRef,
+  TableSource,
+  UpdateAst,
+} from '@prisma-next/sql-relational-core/ast'
+import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan'
+import type { SqlMiddlewareContext } from '@prisma-next/sql-runtime'
+import { vi } from 'vitest'
+import type {
+  CipherstashBulkDecryptArgs,
+  CipherstashBulkEncryptArgs,
+  CipherstashSdk,
+  CipherstashSingleDecryptArgs,
+} from '../src/execution/sdk'
+import { CIPHERSTASH_STRING_CODEC_ID } from '../src/extension-metadata/constants'
+
+export { createSqlParamRefMutator } from '@prisma-next/sql-relational-core/middleware'
+
+export const baseMeta: PlanMeta = {
+  target: 'postgres',
+  storageHash: 'sha256:test',
+  lane: 'dsl',
+}
+
+export function createCtx(
+  overrides?: Partial<SqlMiddlewareContext>,
+): SqlMiddlewareContext {
+  return {
+    contract: {} as Contract<SqlStorage>,
+    mode: 'strict' as const,
+    scope: 'runtime' as const,
+    now: () => Date.now(),
+    log: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+    contentHash: async () => 'mock-hash',
+    planExecutionId: 'test-plan-execution',
+    ...overrides,
+  }
+}
+
+export interface CounterSdk extends CipherstashSdk {
+  readonly bulkEncryptCalls: CipherstashBulkEncryptArgs[]
+  readonly bulkDecryptCalls: CipherstashBulkDecryptArgs[]
+  readonly singleDecryptCalls: CipherstashSingleDecryptArgs[]
+}
+
+export function makeCounterSdk(options?: {
+  encryptImpl?: (args: CipherstashBulkEncryptArgs) => ReadonlyArray<unknown>
+}): CounterSdk {
+  const bulkEncryptCalls: CipherstashBulkEncryptArgs[] = []
+  const bulkDecryptCalls: CipherstashBulkDecryptArgs[] = []
+  const singleDecryptCalls: CipherstashSingleDecryptArgs[] = []
+  const encryptImpl =
+    options?.encryptImpl ??
+    ((args: CipherstashBulkEncryptArgs) =>
+      args.values.map(
+        (plaintext) =>
+          `cipher:${args.routingKey.table}.${args.routingKey.column}:${plaintext}`,
+      ))
+  return {
+    bulkEncryptCalls,
+    bulkDecryptCalls,
+    singleDecryptCalls,
+    decrypt(args) {
+      singleDecryptCalls.push(args)
+      return Promise.resolve(`single:${String(args.ciphertext)}`)
+    },
+    bulkEncrypt(args) {
+      bulkEncryptCalls.push(args)
+      return Promise.resolve(encryptImpl(args))
+    },
+    bulkDecrypt(args) {
+      bulkDecryptCalls.push(args)
+      return Promise.resolve(
+        args.ciphertexts.map((c) => `bulk-decrypt:${String(c)}`),
+      )
+    },
+  }
+}
+
+export function buildInsertPlan(
+  table: string,
+  rows: ReadonlyArray<Record<string, unknown>>,
+  codecId: string = CIPHERSTASH_STRING_CODEC_ID,
+): SqlExecutionPlan {
+  const params: unknown[] = []
+  const astRows = rows.map((row) => {
+    const out: Record<string, ParamRef> = {}
+    for (const [column, value] of Object.entries(row)) {
+      const ref = ParamRef.of(value, {
+        codec: { codecId },
+      })
+      out[column] = ref
+      params.push(value)
+    }
+    return out
+  })
+  const ast = new InsertAst(TableSource.named(table), astRows)
+  return {
+    sql: `INSERT INTO "${table}" (...) VALUES (...)`,
+    params,
+    meta: { ...baseMeta },
+    ast,
+  } as SqlExecutionPlan
+}
+
+export function buildUpdatePlan(
+  table: string,
+  set: Record<string, unknown>,
+  codecId: string = CIPHERSTASH_STRING_CODEC_ID,
+): SqlExecutionPlan {
+  const params: unknown[] = []
+  const astSet: Record<string, ParamRef | ColumnRef> = {}
+  for (const [column, value] of Object.entries(set)) {
+    const ref = ParamRef.of(value, {
+      codec: { codecId },
+    })
+    astSet[column] = ref
+    params.push(value)
+  }
+  const ast = new UpdateAst(TableSource.named(table), astSet)
+  return {
+    sql: `UPDATE "${table}" SET ...`,
+    params,
+    meta: { ...baseMeta },
+    ast,
+  } as SqlExecutionPlan
+}
diff --git a/packages/prisma-next/test/bulk-encrypt-middleware.test.ts b/packages/prisma-next/test/bulk-encrypt-middleware.test.ts
index 7a4efc00..f1d8a19a 100644
--- a/packages/prisma-next/test/bulk-encrypt-middleware.test.ts
+++ b/packages/prisma-next/test/bulk-encrypt-middleware.test.ts
@@ -23,143 +23,27 @@
  * SDK-shape error path (wrong number of ciphertexts → diagnostic).
  */
 
-import type { Contract, PlanMeta } from '@prisma-next/contract/types'
-import type { SqlStorage } from '@prisma-next/sql-contract/types'
 import {
-  type ColumnRef,
   InsertAst,
   ParamRef,
   TableSource,
-  UpdateAst,
 } from '@prisma-next/sql-relational-core/ast'
-import { createSqlParamRefMutator } from '@prisma-next/sql-relational-core/middleware'
 import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan'
-import type { SqlMiddlewareContext } from '@prisma-next/sql-runtime'
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import {
   EncryptedString,
   setHandleRoutingKey,
 } from '../src/execution/envelope-string'
-import type {
-  CipherstashBulkDecryptArgs,
-  CipherstashBulkEncryptArgs,
-  CipherstashSdk,
-  CipherstashSingleDecryptArgs,
-} from '../src/execution/sdk'
 import { CIPHERSTASH_STRING_CODEC_ID } from '../src/extension-metadata/constants'
 import { bulkEncryptMiddleware } from '../src/middleware/bulk-encrypt'
-
-const baseMeta: PlanMeta = {
-  target: 'postgres',
-  storageHash: 'sha256:test',
-  lane: 'dsl',
-}
-
-function createCtx(
-  overrides?: Partial<SqlMiddlewareContext>,
-): SqlMiddlewareContext {
-  return {
-    contract: {} as Contract<SqlStorage>,
-    mode: 'strict' as const,
-    scope: 'runtime' as const,
-    now: () => Date.now(),
-    log: {
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    },
-    contentHash: async () => 'mock-hash',
-    planExecutionId: 'test-plan-execution',
-    ...overrides,
-  }
-}
-
-interface CounterSdk extends CipherstashSdk {
-  readonly bulkEncryptCalls: CipherstashBulkEncryptArgs[]
-  readonly bulkDecryptCalls: CipherstashBulkDecryptArgs[]
-  readonly singleDecryptCalls: CipherstashSingleDecryptArgs[]
-}
-
-function makeCounterSdk(options?: {
-  encryptImpl?: (args: CipherstashBulkEncryptArgs) => ReadonlyArray<unknown>
-}): CounterSdk {
-  const bulkEncryptCalls: CipherstashBulkEncryptArgs[] = []
-  const bulkDecryptCalls: CipherstashBulkDecryptArgs[] = []
-  const singleDecryptCalls: CipherstashSingleDecryptArgs[] = []
-  const encryptImpl =
-    options?.encryptImpl ??
-    ((args: CipherstashBulkEncryptArgs) =>
-      args.values.map(
-        (plaintext) =>
-          `cipher:${args.routingKey.table}.${args.routingKey.column}:${plaintext}`,
-      ))
-  return {
-    bulkEncryptCalls,
-    bulkDecryptCalls,
-    singleDecryptCalls,
-    decrypt(args) {
-      singleDecryptCalls.push(args)
-      return Promise.resolve(`single:${String(args.ciphertext)}`)
-    },
-    bulkEncrypt(args) {
-      bulkEncryptCalls.push(args)
-      return Promise.resolve(encryptImpl(args))
-    },
-    bulkDecrypt(args) {
-      bulkDecryptCalls.push(args)
-      return Promise.resolve(
-        args.ciphertexts.map((c) => `bulk-decrypt:${String(c)}`),
-      )
-    },
-  }
-}
-
-function buildInsertPlan(
-  table: string,
-  rows: ReadonlyArray<Record<string, unknown>>,
-): SqlExecutionPlan {
-  const params: unknown[] = []
-  const astRows = rows.map((row) => {
-    const out: Record<string, ParamRef> = {}
-    for (const [column, value] of Object.entries(row)) {
-      const ref = ParamRef.of(value, {
-        codec: { codecId: CIPHERSTASH_STRING_CODEC_ID },
-      })
-      out[column] = ref
-      params.push(value)
-    }
-    return out
-  })
-  const ast = new InsertAst(TableSource.named(table), astRows)
-  return {
-    sql: `INSERT INTO "${table}" (...) VALUES (...)`,
-    params,
-    meta: { ...baseMeta },
-    ast,
-  } as SqlExecutionPlan
-}
-
-function buildUpdatePlan(
-  table: string,
-  set: Record<string, unknown>,
-): SqlExecutionPlan {
-  const params: unknown[] = []
-  const astSet: Record<string, ParamRef | ColumnRef> = {}
-  for (const [column, value] of Object.entries(set)) {
-    const ref = ParamRef.of(value, {
-      codec: { codecId: CIPHERSTASH_STRING_CODEC_ID },
-    })
-    astSet[column] = ref
-    params.push(value)
-  }
-  const ast = new UpdateAst(TableSource.named(table), astSet)
-  return {
-    sql: `UPDATE "${table}" SET ...`,
-    params,
-    meta: { ...baseMeta },
-    ast,
-  } as SqlExecutionPlan
-}
+import {
+  baseMeta,
+  buildInsertPlan,
+  buildUpdatePlan,
+  createCtx,
+  createSqlParamRefMutator,
+  makeCounterSdk,
+} from './bulk-encrypt-middleware.helpers'
 
 describe('bulkEncryptMiddleware', () => {
   describe('one bulkEncrypt call per (table, column) group', () => {
diff --git a/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
new file mode 100644
index 00000000..01dcc00c
--- /dev/null
+++ b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
@@ -0,0 +1,368 @@
+/**
+ * v3 bulk-encrypt middleware behaviour.
+ *
+ * Mirrors the v2 suite's contract (`../bulk-encrypt-middleware.test.ts`)
+ * via the shared harness, with the two v3-specific deltas under test:
+ *
+ *   - **Jurisdiction** is the v3 codec-id set only: v2-codec'd params
+ *     (and non-cipherstash params) are invisible to this middleware.
+ *   - **Wire** is plain JSONB text (`v3ToDriver` of the EQL payload) —
+ *     never the v2 `eql_v2_encrypted` composite literal (`("...")`).
+ *
+ * The mock SDK returns object EQL payloads (`{ c: ... }`) so the tests
+ * observe the JSON.stringify boundary the pg driver will see.
+ */
+
+import {
+  InsertAst,
+  ParamRef,
+  TableSource,
+} from '@prisma-next/sql-relational-core/ast'
+import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan'
+import { describe, expect, it } from 'vitest'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { CIPHERSTASH_STRING_CODEC_ID } from '../../src/extension-metadata/constants'
+import { isCipherstashV3CodecId } from '../../src/extension-metadata/constants-v3'
+import { bulkEncryptMiddlewareV3 } from '../../src/v3/bulk-encrypt-v3'
+import {
+  baseMeta,
+  buildInsertPlan,
+  buildUpdatePlan,
+  createCtx,
+  createSqlParamRefMutator,
+  makeCounterSdk,
+} from '../bulk-encrypt-middleware.helpers'
+
+const V3_TEXT_SEARCH = 'cipherstash/eql-v3/eql_v3_text_search@1'
+const V3_JSON = 'cipherstash/eql-v3/eql_v3_json@1'
+
+it('test fixture codec ids are members of the pinned v3 set', () => {
+  expect(isCipherstashV3CodecId(V3_TEXT_SEARCH)).toBe(true)
+  expect(isCipherstashV3CodecId(V3_JSON)).toBe(true)
+  expect(isCipherstashV3CodecId(CIPHERSTASH_STRING_CODEC_ID)).toBe(false)
+})
+
+/** SDK whose ciphertexts are object EQL payloads, the v3 SDK shape. */
+function makeV3Sdk() {
+  return makeCounterSdk({
+    encryptImpl: (args) =>
+      args.values.map((plaintext) => ({ c: `enc:${String(plaintext)}` })),
+  })
+}
+
+describe('bulkEncryptMiddlewareV3', () => {
+  describe('identity', () => {
+    it('declares the SQL family + the v3 middleware name', () => {
+      const middleware = bulkEncryptMiddlewareV3(makeV3Sdk())
+      expect(middleware.familyId).toBe('sql')
+      expect(middleware.name).toBe('cipherstash.bulk-encrypt-v3')
+    })
+  })
+
+  describe('param slot carries plain JSONB text post-middleware', () => {
+    it('bulk-encrypts v3 params and writes plain JSONB (never the v2 composite)', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: envelope }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.routingKey).toEqual({
+        table: 'user',
+        column: 'email',
+      })
+      const finalParams = params.currentParams()
+      expect(finalParams).toHaveLength(1)
+      const onlyParam = finalParams[0]
+      expect(onlyParam).toBe('{"c":"enc:alice@example.com"}')
+      // Never the v2 `eql_v2_encrypted` composite literal.
+      expect(onlyParam).not.toMatch(/^\(/)
+    })
+
+    it('round-trips a json castAs envelope (EncryptedJson) like the others', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plaintext = { role: 'admin', tags: ['a', 'b'] }
+      const envelope = EncryptedJson.from(plaintext)
+      const plan = buildInsertPlan('doc', [{ payload: envelope }], V3_JSON)
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      // The SDK sees the original JS object plaintext untouched.
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.values).toEqual([plaintext])
+      // The param slot carries the serialised EQL payload; the handle
+      // keeps both slots for follow-on reuse.
+      expect(params.currentParams()[0]).toBe('{"c":"enc:[object Object]"}')
+      expect(envelope.expose().ciphertext).toEqual({
+        c: 'enc:[object Object]',
+      })
+      expect(envelope.expose().plaintext).toEqual(plaintext)
+      await expect(envelope.decrypt()).resolves.toEqual(plaintext)
+      expect(sdk.singleDecryptCalls).toEqual([])
+    })
+  })
+
+  describe('one bulkEncrypt call per (table, column) group', () => {
+    it('collapses N rows in one column into a single SDK round-trip', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelopes = Array.from({ length: 10 }, (_, i) =>
+        EncryptedString.from(`alice${i}@example.com`),
+      )
+      const plan = buildInsertPlan(
+        'user',
+        envelopes.map((e) => ({ email: e })),
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.values).toEqual(
+        envelopes.map((_, i) => `alice${i}@example.com`),
+      )
+      expect(params.currentParams()).toEqual(
+        envelopes.map((_, i) => `{"c":"enc:alice${i}@example.com"}`),
+      )
+    })
+
+    it('partitions targets across (table, column) groups', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [
+          {
+            email: EncryptedString.from('a@x.com'),
+            username: EncryptedString.from('alice'),
+          },
+          {
+            email: EncryptedString.from('b@x.com'),
+            username: EncryptedString.from('bob'),
+          },
+        ],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(2)
+      const byColumn = new Map(
+        sdk.bulkEncryptCalls.map((c) => [c.routingKey.column, c]),
+      )
+      expect(byColumn.get('email')?.values).toEqual(['a@x.com', 'b@x.com'])
+      expect(byColumn.get('username')?.values).toEqual(['alice', 'bob'])
+    })
+
+    it('stamps (table, column) from UpdateAst before grouping', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildUpdatePlan(
+        'admin',
+        { email: EncryptedString.from('alice@example.com') },
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.routingKey).toEqual({
+        table: 'admin',
+        column: 'email',
+      })
+      expect(params.currentParams()[0]).toBe('{"c":"enc:alice@example.com"}')
+    })
+  })
+
+  describe('jurisdiction is the v3 codec-id set only', () => {
+    it('ignores v2-codec params', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: EncryptedString.from('x') }],
+        CIPHERSTASH_STRING_CODEC_ID,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+
+    it('ignores non-cipherstash codec ids and uncodec’d params', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const ast = new InsertAst(TableSource.named('user'), [
+        {
+          id: ParamRef.of(1, { codec: { codecId: 'pg/text@1' } }),
+          name: ParamRef.of('plain'),
+        },
+      ])
+      const plan = {
+        sql: 'INSERT INTO "user" (id, name) VALUES ($1, $2)',
+        params: [1, 'plain'],
+        meta: { ...baseMeta },
+        ast,
+      } as SqlExecutionPlan
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+  })
+
+  describe('ctx.signal is forwarded by identity to the SDK', () => {
+    it('passes ctx.signal to bulkEncrypt by reference', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: EncryptedString.from('alice@example.com') }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+      const controller = new AbortController()
+
+      await middleware.beforeExecute?.(
+        plan,
+        createCtx({ signal: controller.signal }),
+        params,
+      )
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.signal).toBe(controller.signal)
+    })
+
+    it('omits signal when ctx.signal is undefined', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: EncryptedString.from('alice@example.com') }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.signal).toBeUndefined()
+    })
+
+    it('short-circuits with RUNTIME.ABORTED before any SDK call when already aborted', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: EncryptedString.from('alice@example.com') }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+      const controller = new AbortController()
+      controller.abort()
+
+      await expect(
+        middleware.beforeExecute?.(
+          plan,
+          createCtx({ signal: controller.signal }),
+          params,
+        ),
+      ).rejects.toThrow()
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+  })
+
+  describe('plaintext slot is retained post-encrypt', () => {
+    it('decrypt() returns plaintext synchronously without consulting the SDK', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: envelope }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(envelope.expose().plaintext).toBe('alice@example.com')
+      await expect(envelope.decrypt()).resolves.toBe('alice@example.com')
+      expect(sdk.singleDecryptCalls).toEqual([])
+      expect(sdk.bulkDecryptCalls).toEqual([])
+    })
+  })
+
+  describe('no-op cases', () => {
+    it('skips when params is undefined', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = {
+        sql: 'SELECT 1',
+        params: [],
+        meta: { ...baseMeta },
+      } as unknown as SqlExecutionPlan
+
+      await middleware.beforeExecute?.(plan, createCtx())
+
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+  })
+
+  describe('error paths', () => {
+    it('throws when the SDK returns the wrong number of ciphertexts', async () => {
+      const sdk = makeCounterSdk({ encryptImpl: () => [{ c: 'only-one' }] })
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const plan = buildInsertPlan(
+        'user',
+        [
+          { email: EncryptedString.from('a@x') },
+          { email: EncryptedString.from('b@y') },
+        ],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await expect(
+        middleware.beforeExecute?.(plan, createCtx(), params),
+      ).rejects.toThrow(/1 ciphertexts.*2 were requested/)
+    })
+
+    it('throws on a v3-codec envelope with no plaintext', async () => {
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.fromInternal({
+        ciphertext: { c: 'pre-existing' },
+        table: 'user',
+        column: 'email',
+        sdk,
+      })
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: envelope }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await expect(
+        middleware.beforeExecute?.(plan, createCtx(), params),
+      ).rejects.toThrow(/no plaintext/)
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+  })
+})

From faa3976cb22bf3f57456b812eccdfcc78f675d8e Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 13:34:39 -0600
Subject: [PATCH 06/21] =?UTF-8?q?feat(prisma-next):=20v3=20query=20operato?=
 =?UTF-8?q?rs=20=E2=80=94=20eql=5Fv3.*=20lowering=20+=20capability=20gatin?=
 =?UTF-8?q?g?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add cipherstashV3QueryOperations() (src/v3/operators-v3.ts): the EQL v3
operator set registered by the v3 extension descriptor only (decision 1b
— same cipherstash* method names as v2, never co-registered; the flat
OperationRegistry collision is pinned by test).

Lowering matches the stack-drizzle v3 dialect byte-for-byte: operands
are ciphertext-free query terms cast to the column domain's
eql_v3.query_<domain> type (eql_v3.eq/neq/gt/gte/lt/lte/contains,
self-parenthesised (gte AND lte) range, OR-of-eq membership), JSON
containment is OPERATOR(public.@>) with the irregular
::eql_v3.query_jsonb cast (cipherstashJsonContains, empty-needle
guarded), and ordering extracts eql_v3.ord_term / ord_term_ore by the
domain's flavour via the free-standing cipherstashV3Asc/Desc helpers.

Operands are bound as pg/text@1 params (bare $N; the template supplies
the query cast — the column codec's storage-domain cast would fail the
query term's CHECK) and each envelope is routing-key stamped plus
marked with its queryType (markV3QueryTerm / v3QueryTermTypeOf), the
seam Task 7's SDK adapter uses to route WHERE operands through
encryptQuery instead of storage bulkEncrypt.

Every operator gates on the concrete domain's catalog capabilities and
throws the v3-owned EncryptionOperatorError naming column, domain,
operator, and missing capability. v3 codec descriptors are pinned to
cipherstash:*-only traits alongside the v2 equality-trait regression.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/src/v3/operators-v3.ts   | 813 ++++++++++++++++++
 .../test/equality-trait-removal.test.ts       |  21 +
 .../test/v3/operator-gating-v3.test.ts        | 193 +++++
 .../v3/operator-lowering-v3-equality.test.ts  | 243 ++++++
 .../test/v3/operator-lowering-v3-json.test.ts |  98 +++
 .../operator-lowering-v3-order-range.test.ts  | 160 ++++
 .../operator-lowering-v3-text-search.test.ts  |  82 ++
 .../test/v3/operator-lowering-v3.helpers.ts   | 293 +++++++
 8 files changed, 1903 insertions(+)
 create mode 100644 packages/prisma-next/src/v3/operators-v3.ts
 create mode 100644 packages/prisma-next/test/v3/operator-gating-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
 create mode 100644 packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
 create mode 100644 packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
 create mode 100644 packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
 create mode 100644 packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts

diff --git a/packages/prisma-next/src/v3/operators-v3.ts b/packages/prisma-next/src/v3/operators-v3.ts
new file mode 100644
index 00000000..5dc45815
--- /dev/null
+++ b/packages/prisma-next/src/v3/operators-v3.ts
@@ -0,0 +1,813 @@
+/**
+ * Cipherstash v3 query-operations registry — the EQL v3 twin of the v2
+ * `../execution/operators.ts`, lowering to the canonical v3 dialect
+ * (`packages/stack-drizzle/src/v3/{operators,sql-dialect}.ts` is the
+ * byte-for-byte reference):
+ *
+ *     eql_v3.eq(<col>, $n::eql_v3.query_<domain>)      -- equality
+ *     eql_v3.gt(<col>, $n::eql_v3.query_<domain>)      -- comparison
+ *     eql_v3.contains(<col>, $n::eql_v3.query_<domain>) -- bloom free-text
+ *     <col> OPERATOR(public.@>) $n::eql_v3.query_jsonb  -- JSON containment
+ *     eql_v3.ord_term(<col>) / eql_v3.ord_term_ore(<col>) -- ordering
+ *
+ * ## Operands are QUERY TERMS, not storage envelopes
+ *
+ * Unlike v2 (where a WHERE operand is storage-encrypted by the
+ * bulk-encrypt middleware and compared as a full `eql_v2_encrypted`
+ * value), a v3 operand is a CIPHERTEXT-FREE query term minted by the
+ * stack client's `encryptQuery`, cast to the column domain's
+ * `eql_v3.query_<domain>` type. The cast is load-bearing: it reaches
+ * the bundle's `(domain, query_<domain>)` overloads — the
+ * storage-domain overload's CHECK demands the ciphertext `c` a query
+ * term deliberately omits.
+ *
+ * At lowering time the operator therefore:
+ *
+ *   1. wraps the plaintext in the per-castAs `Encrypted*` envelope and
+ *      stamps the column's `(table, column)` routing key (same
+ *      write-once contract as v2 — SELECT envelopes must arrive at the
+ *      middleware already routing-keyed);
+ *   2. marks the envelope as a QUERY TERM with its `queryType`
+ *      (`markV3QueryTerm` / `v3QueryTermTypeOf`) — the seam Task 7's
+ *      SDK adapter consumes to route the operand through
+ *      `encryptQuery({ queryType })` instead of the storage
+ *      `bulkEncrypt` path;
+ *   3. binds the envelope as a `pg/text@1` `ParamRef`. Deliberately NOT
+ *      the column's own v3 codec: the Postgres renderer emits
+ *      `$N::<nativeType>` for any codec-bound param, and the column
+ *      codec's nativeType is the STORAGE domain (`public.eql_v3_*`) —
+ *      whose CHECK a query term fails. `pg/text@1` renders a bare `$N`
+ *      (text is planner-inferrable), the template supplies the
+ *      `::eql_v3.query_<domain>` cast, and the driver value at execute
+ *      time is the query term's JSONB text — a string, so the codec is
+ *      truthful. The `pg/text@1` codec id also keeps these params
+ *      OUTSIDE the storage bulk-encrypt middleware's jurisdiction
+ *      (it matches on the v3 codec-id set), which is exactly right:
+ *      query terms must never be storage-encrypted.
+ *
+ * ## Capability gating
+ *
+ * Trait dispatch (`cipherstash:*` traits on the codec descriptors)
+ * decides which METHODS are visible on a column; the per-domain gate
+ * here decides whether the CONCRETE domain can answer the call, and
+ * throws {@link EncryptionOperatorError} naming the column, domain,
+ * operator, and missing capability. Both layers are needed: traits are
+ * derivation-time metadata, while a caller can reach a descriptor's
+ * `impl` through a custom builder with any column expression.
+ *
+ * ## v2/v3 method-name identity (decision 1b)
+ *
+ * The registered method names (`cipherstashEq`, `cipherstashGt`, …)
+ * are IDENTICAL to the v2 set — safe because the v2 and v3 runtime
+ * descriptors are separate entry points that are never co-registered
+ * (the flat `OperationRegistry` would throw on the shared names;
+ * pinned in `test/v3/operator-gating-v3.test.ts`). This module imports
+ * NO v2 codec/wire code — only the version-neutral envelope classes
+ * and the shared trait constants.
+ */
+
+import type { QueryTypeName } from '@cipherstash/stack/types'
+import type { CodecTrait } from '@prisma-next/framework-components/codec'
+import type {
+  SqlOperationDescriptor,
+  SqlOperationDescriptors,
+} from '@prisma-next/sql-operations'
+import {
+  type AnyExpression,
+  type CodecRef,
+  type ColumnRef,
+  OrderByItem,
+  ParamRef,
+} from '@prisma-next/sql-relational-core/ast'
+import {
+  buildOperation,
+  codecOf,
+  type Expression,
+  type ScopeField,
+  toExpr,
+} from '@prisma-next/sql-relational-core/expression'
+import {
+  EncryptedEnvelopeBase,
+  setHandleRoutingKey,
+} from '../execution/envelope-base'
+import { EncryptedBigInt } from '../execution/envelope-bigint'
+import { EncryptedBoolean } from '../execution/envelope-boolean'
+import { EncryptedDate } from '../execution/envelope-date'
+import { EncryptedJson } from '../execution/envelope-json'
+import { EncryptedString } from '../execution/envelope-string'
+import {
+  CIPHERSTASH_TRAIT_EQUALITY,
+  CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+  CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+  CIPHERSTASH_TRAIT_SEARCHABLE_JSON,
+} from '../extension-metadata/constants-v3'
+import { V3_DOMAIN_META_BY_CODEC_ID, type V3DomainMeta } from './catalog'
+import { EncryptedNumber } from './envelope-number'
+
+/**
+ * Codec ID of the framework's Postgres boolean codec — referenced as a
+ * string so cipherstash does not pick up a peer-dep on the target
+ * package just to identify a return-codec id (same pattern as v2).
+ */
+const PG_BOOL_CODEC_ID = 'pg/bool@1' as const
+
+/**
+ * Codec bound to every query-term `ParamRef` — see the module doc
+ * ("Operands are QUERY TERMS") for why this is `pg/text@1` and not the
+ * column's own v3 codec.
+ */
+const QUERY_TERM_PARAM_CODEC: CodecRef = { codecId: 'pg/text@1' }
+
+type PgBoolReturn = {
+  readonly codecId: typeof PG_BOOL_CODEC_ID
+  readonly nullable: false
+}
+
+/**
+ * A dedicated error for v3 operator gating, operand-coercion, and
+ * misuse failures, carrying the offending column/table/operator for
+ * diagnostics.
+ *
+ * INTENTIONAL FORK of `@cipherstash/stack-drizzle`'s error of the same
+ * name (same shape, same rationale): sharing it would couple two
+ * independently-versioned public packages. v3-owned — the v2 operator
+ * surface keeps throwing plain `TypeError`s.
+ */
+export class EncryptionOperatorError extends Error {
+  constructor(
+    message: string,
+    public readonly context?: {
+      columnName?: string
+      tableName?: string
+      operator?: string
+    },
+  ) {
+    super(message)
+    this.name = 'EncryptionOperatorError'
+  }
+}
+
+/**
+ * The query-term flavours a v3 operator can mint — the subset of the
+ * stack's `QueryTypeName` union that maps 1:1 onto the four
+ * capability families (`steVecSelector`/`steVecTerm` are subsumed by
+ * `searchableJson`, which auto-infers).
+ */
+export type V3QueryTermType = Extract<
+  QueryTypeName,
+  'equality' | 'orderAndRange' | 'freeTextSearch' | 'searchableJson'
+>
+
+/**
+ * Query-term marks, keyed by envelope identity. A WeakMap sidecar
+ * rather than a handle slot so the version-neutral
+ * `EncryptedEnvelopeHandle` (shared with v2, which has no query-term
+ * concept) stays untouched.
+ */
+const V3_QUERY_TERM_TYPES = new WeakMap<
+  EncryptedEnvelopeBase<unknown>,
+  V3QueryTermType
+>()
+
+/**
+ * Mark an envelope as a v3 QUERY TERM of the given flavour. Stamped by
+ * every operator at lowering time; consumed by the v3 SDK boundary
+ * (Task 7), which must encrypt marked envelopes via
+ * `encryptQuery({ queryType })` — a ciphertext-free term — instead of
+ * the storage `bulkEncrypt` path. Write-once-wins with a conflict
+ * check, mirroring `setHandleRoutingKey`: one envelope instance feeds
+ * one query flavour.
+ */
+export function markV3QueryTerm(
+  envelope: EncryptedEnvelopeBase<unknown>,
+  queryType: V3QueryTermType,
+): void {
+  const existing = V3_QUERY_TERM_TYPES.get(envelope)
+  if (existing !== undefined && existing !== queryType) {
+    throw new EncryptionOperatorError(
+      `cipherstash v3 operator: envelope is already marked as a "${existing}" query term, refusing to remark as "${queryType}". Construct a fresh envelope per operator call.`,
+    )
+  }
+  V3_QUERY_TERM_TYPES.set(envelope, queryType)
+}
+
+/**
+ * Read an envelope's query-term mark. `undefined` means the envelope
+ * is a storage value (write path), not a query term.
+ */
+export function v3QueryTermTypeOf(
+  envelope: unknown,
+): V3QueryTermType | undefined {
+  return envelope instanceof EncryptedEnvelopeBase
+    ? V3_QUERY_TERM_TYPES.get(envelope)
+    : undefined
+}
+
+/** Per-call column context resolved from the `self` expression. */
+interface ColumnContext {
+  readonly meta: V3DomainMeta
+  readonly selfCodec: CodecRef
+  readonly selfAst: AnyExpression
+  readonly columnName: string | undefined
+  readonly tableName: string | undefined
+}
+
+/**
+ * The `eql_v3.query_<domain>` cast for a column's storage domain —
+ * `public.eql_v3_text_search` → `eql_v3.query_text_search`. Uniform
+ * across the queryable column domains (`_eq`, `_ord`, `_ord_ore`,
+ * `_match`, `_search`); the irregular cases are handled elsewhere:
+ * storage-only domains have no query type (they are gated out before
+ * a template is built) and `eql_v3_json` maps to the irregular
+ * `eql_v3.query_jsonb`, cast explicitly on the JSON path.
+ */
+function queryCastForMeta(meta: V3DomainMeta): string | null {
+  const prefix = 'eql_v3_'
+  if (!meta.bareDomain.startsWith(prefix)) return null
+  const suffix = meta.bareDomain.slice(prefix.length)
+  if (!/_(eq|ord|ord_ore|match|search)$/.test(suffix)) {
+    return null
+  }
+  return `eql_v3.query_${suffix}`
+}
+
+function requireSelfCodec(
+  self: Expression<ScopeField>,
+  method: string,
+): CodecRef {
+  const codec = codecOf(self)
+  if (codec === undefined) {
+    throw new EncryptionOperatorError(
+      `cipherstash ${method}: self expression is missing a CodecRef. ` +
+        'Cipherstash predicate operators require a column-bound self argument; ' +
+        'reach the operator through the ORM model-accessor (e.g. `model.users.where((u) => u.email.cipherstashEq(...))`).',
+      { operator: method },
+    )
+  }
+  return codec
+}
+
+/**
+ * Find the column reference inside a `self` expression so the operator
+ * can stamp routing keys and name the column in diagnostics. Same
+ * resolution ladder as v2: a direct `ColumnRef`, then the
+ * `baseColumnRef()` walk, then `undefined` (literal self — routing
+ * stamping is skipped and the middleware surfaces the missing-routing
+ * diagnostic at execute time).
+ */
+function extractColumnRef(selfAst: AnyExpression): ColumnRef | undefined {
+  if (selfAst.kind === 'column-ref') {
+    return selfAst
+  }
+  try {
+    return selfAst.baseColumnRef()
+  } catch {
+    return undefined
+  }
+}
+
+function resolveContext(
+  self: Expression<ScopeField>,
+  method: string,
+): ColumnContext {
+  const selfCodec = requireSelfCodec(self, method)
+  const selfAst = toExpr(self, selfCodec)
+  const columnRef = extractColumnRef(selfAst)
+  const meta = V3_DOMAIN_META_BY_CODEC_ID.get(selfCodec.codecId)
+  if (!meta) {
+    throw new EncryptionOperatorError(
+      `cipherstash ${method}: column codec id "${selfCodec.codecId}" is not a public.eql_v3_* v3 domain. ` +
+        'v2 cipherstash columns are the wrong entry point for the v3 operator surface — ' +
+        'a client is v2 or v3, never both (decision 1b).',
+      {
+        operator: method,
+        ...(columnRef ? { columnName: columnRef.column } : {}),
+        ...(columnRef ? { tableName: columnRef.table } : {}),
+      },
+    )
+  }
+  return {
+    meta,
+    selfCodec,
+    selfAst,
+    columnName: columnRef?.column,
+    tableName: columnRef?.table,
+  }
+}
+
+/**
+ * Gate an operator on the concrete domain's query capabilities. The
+ * capability set is intrinsic to the domain (catalog-derived — the
+ * same source that drives the codec descriptors' traits and the
+ * authoring `typeParams.capabilities` block), so gating here can never
+ * disagree with what the column advertises.
+ */
+function gate(
+  ctx: ColumnContext,
+  capability: keyof V3DomainMeta['capabilities'],
+  label: string,
+  method: string,
+): void {
+  if (!ctx.meta.capabilities[capability]) {
+    throw new EncryptionOperatorError(
+      `Operator "${method}" requires ${label} on column "${ctx.columnName ?? 'unknown'}" (domain ${ctx.meta.nativeType} does not support it).`,
+      {
+        columnName: ctx.columnName ?? 'unknown',
+        tableName: ctx.tableName ?? 'unknown',
+        operator: method,
+      },
+    )
+  }
+}
+
+function operatorError(
+  ctx: ColumnContext,
+  method: string,
+  message: string,
+): EncryptionOperatorError {
+  return new EncryptionOperatorError(message, {
+    columnName: ctx.columnName ?? 'unknown',
+    tableName: ctx.tableName ?? 'unknown',
+    operator: method,
+  })
+}
+
+function requireNonNullOperand(
+  ctx: ColumnContext,
+  value: unknown,
+  method: string,
+): void {
+  if (value == null) {
+    throw operatorError(
+      ctx,
+      method,
+      `cipherstash ${method}: cannot encrypt a null operand for column "${ctx.columnName ?? 'unknown'}". Use isNull() or isNotNull() for NULL checks.`,
+    )
+  }
+}
+
+/**
+ * Coerce a user-supplied value into the envelope subclass matching the
+ * domain's `castAs` (raw plaintext or a pre-built envelope). Total
+ * over `V3CastAs`; the diagnostic names the expected plaintext type.
+ */
+function coerceV3(
+  ctx: ColumnContext,
+  value: unknown,
+  method: string,
+): EncryptedEnvelopeBase<unknown> {
+  requireNonNullOperand(ctx, value, method)
+  switch (ctx.meta.castAs) {
+    case 'string':
+      if (value instanceof EncryptedString) return value
+      if (typeof value === 'string') return EncryptedString.from(value)
+      break
+    case 'number':
+      if (value instanceof EncryptedNumber) return value
+      if (typeof value === 'number') return EncryptedNumber.from(value)
+      break
+    case 'bigint':
+      if (value instanceof EncryptedBigInt) return value
+      if (typeof value === 'bigint') return EncryptedBigInt.from(value)
+      break
+    case 'date':
+    case 'timestamp':
+      if (value instanceof EncryptedDate) return value
+      if (value instanceof Date) return EncryptedDate.from(value)
+      break
+    case 'boolean':
+      if (value instanceof EncryptedBoolean) return value
+      if (typeof value === 'boolean') return EncryptedBoolean.from(value)
+      break
+    case 'json':
+      if (value instanceof EncryptedJson) return value
+      return EncryptedJson.from(value)
+  }
+  const got =
+    value === null ? 'null' : value instanceof Date ? 'Date' : typeof value
+  throw operatorError(
+    ctx,
+    method,
+    `cipherstash ${method}: value is not assignable to castAs "${ctx.meta.castAs}" for domain ${ctx.meta.nativeType}, got ${got}.`,
+  )
+}
+
+/**
+ * Wrap a user value as a query-term `ParamRef`: coerce to the
+ * per-castAs envelope, stamp the `(table, column)` routing key
+ * (write-once-wins), mark the query-term flavour for the SDK boundary,
+ * and bind under the bare-rendering `pg/text@1` codec (the template
+ * supplies the `::eql_v3.query_<domain>` cast).
+ */
+function asQueryTermParam(
+  ctx: ColumnContext,
+  value: unknown,
+  method: string,
+  queryType: V3QueryTermType,
+): ParamRef {
+  const envelope = coerceV3(ctx, value, method)
+  if (ctx.tableName !== undefined && ctx.columnName !== undefined) {
+    setHandleRoutingKey(envelope, ctx.tableName, ctx.columnName)
+  }
+  markV3QueryTerm(envelope, queryType)
+  return ParamRef.of(envelope, { codec: QUERY_TERM_PARAM_CODEC })
+}
+
+/**
+ * The `::eql_v3.query_<domain>` cast for a gated context. The gate ran
+ * first, so a missing query type here means the catalog and the gate
+ * disagree — an internal invariant violation, not a user error.
+ */
+function requireQueryCast(ctx: ColumnContext, method: string): string {
+  const cast = queryCastForMeta(ctx.meta)
+  if (cast === null) {
+    throw operatorError(
+      ctx,
+      method,
+      `cipherstash ${method}: domain ${ctx.meta.nativeType} passed its capability gate but has no eql_v3.query_* operand type. This is a bug in @cipherstash/prisma-next — please report it.`,
+    )
+  }
+  return cast
+}
+
+interface GateSpec {
+  readonly capability: keyof V3DomainMeta['capabilities']
+  readonly label: string
+}
+
+const EQUALITY_GATE: GateSpec = { capability: 'equality', label: 'equality' }
+const ORDERING_GATE: GateSpec = {
+  capability: 'orderAndRange',
+  label: 'order/range',
+}
+const FREE_TEXT_GATE: GateSpec = {
+  capability: 'freeTextSearch',
+  label: 'free-text search',
+}
+const JSON_GATE: GateSpec = {
+  capability: 'searchableJson',
+  label: 'JSON containment',
+}
+
+/**
+ * Build a fixed-arity v3 predicate operator dispatched via a
+ * cipherstash-namespaced trait. The lowering template is built PER
+ * CALL from the concrete domain (the `::eql_v3.query_<domain>` cast is
+ * domain-dependent), via {@link buildTemplate} over the resolved cast.
+ */
+function fixedArityOperator(
+  method: string,
+  trait: string,
+  arity: number,
+  gateSpec: GateSpec,
+  queryType: V3QueryTermType,
+  buildTemplate: (cast: string) => string,
+): SqlOperationDescriptor {
+  return {
+    // Cipherstash trait identifiers (`cipherstash:equality`, …) live
+    // outside the framework's closed `CodecTrait` union; the runtime
+    // dispatcher widens to `readonly string[]` before matching. Same
+    // pattern (and full rationale) as the v2 operators and
+    // `codec-runtime-v3.ts`; AGENTS.md requires this rationale comment
+    // alongside any `as unknown as` cast.
+    self: { traits: [trait] as unknown as readonly CodecTrait[] },
+    impl: (
+      self: Expression<ScopeField>,
+      ...userArgs: unknown[]
+    ): Expression<PgBoolReturn> => {
+      if (userArgs.length !== arity) {
+        throw new EncryptionOperatorError(
+          `cipherstash ${method}: expected ${arity} argument${arity === 1 ? '' : 's'}, got ${userArgs.length}.`,
+          { operator: method },
+        )
+      }
+      const ctx = resolveContext(self, method)
+      gate(ctx, gateSpec.capability, gateSpec.label, method)
+      const cast = requireQueryCast(ctx, method)
+      const argRefs = userArgs.map((value) =>
+        asQueryTermParam(ctx, value, method, queryType),
+      )
+      return buildOperation({
+        method,
+        args: [ctx.selfAst, ...argRefs],
+        returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+        lowering: {
+          targetFamily: 'sql',
+          strategy: 'function',
+          template: buildTemplate(cast),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * Build a variable-arity v3 membership operator
+ * (`cipherstashInArray` / `cipherstashNotInArray`): one query-term
+ * param per array element, template built per call from the array
+ * length AND the domain's query cast. Empty arrays are rejected — an
+ * OR-of-zero fragments has no well-defined lowering, and a silent
+ * `FALSE` rewrite would mask the caller's likely intent.
+ */
+function membershipOperator(
+  method: string,
+  negate: boolean,
+): SqlOperationDescriptor {
+  return {
+    // See `fixedArityOperator` for the cast rationale.
+    self: {
+      traits: [CIPHERSTASH_TRAIT_EQUALITY] as unknown as readonly CodecTrait[],
+    },
+    impl: (
+      self: Expression<ScopeField>,
+      values: unknown,
+    ): Expression<PgBoolReturn> => {
+      if (!Array.isArray(values)) {
+        throw new EncryptionOperatorError(
+          `cipherstash ${method}: expected an array argument, got ${
+            values === null ? 'null' : typeof values
+          }.`,
+          { operator: method },
+        )
+      }
+      if (values.length === 0) {
+        throw new EncryptionOperatorError(
+          `cipherstash ${method}: empty array is not supported. ` +
+            'An empty membership check has no well-defined SQL lowering — use ' +
+            '`WHERE FALSE` directly if you want to match no rows.',
+          { operator: method },
+        )
+      }
+      const ctx = resolveContext(self, method)
+      gate(ctx, EQUALITY_GATE.capability, EQUALITY_GATE.label, method)
+      const cast = requireQueryCast(ctx, method)
+      const argRefs = values.map((value) =>
+        asQueryTermParam(ctx, value, method, 'equality'),
+      )
+      const terms = values.map(
+        (_, i) => `eql_v3.eq({{self}}, {{arg${i}}}::${cast})`,
+      )
+      const disjunction = `(${terms.join(' OR ')})`
+      return buildOperation({
+        method,
+        args: [ctx.selfAst, ...argRefs],
+        returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+        lowering: {
+          targetFamily: 'sql',
+          strategy: 'function',
+          template: negate ? `NOT ${disjunction}` : disjunction,
+        },
+      })
+    },
+  }
+}
+
+/**
+ * Exact encrypted-JSONB containment on an `eql_v3_json` (`ste_vec`)
+ * column: genuine jsonb `@>`, no false positives. `eql_v3_json` has no
+ * `eql_v3.contains` overload — containment is the `@>` operator, whose
+ * `(eql_v3_json, eql_v3.query_jsonb)` form takes a NARROWED query term
+ * (searchableJson → no ciphertext) cast to the irregular
+ * `eql_v3.query_jsonb`. The explicit `OPERATOR(public.@>)` spelling
+ * plus the cast disambiguate among the four `eql_v3_json @> ?` RHS
+ * overloads ("operator is not unique", 42725).
+ *
+ * This mirrors the drizzle reference's `contains` under the v2 set's
+ * `cipherstashJson*` naming convention. The reference exposes neither
+ * a containedBy direction nor selector querying, so neither is
+ * registered here.
+ */
+function jsonContainsOperator(): SqlOperationDescriptor {
+  const method = 'cipherstashJsonContains'
+  return {
+    // See `fixedArityOperator` for the cast rationale.
+    self: {
+      traits: [
+        CIPHERSTASH_TRAIT_SEARCHABLE_JSON,
+      ] as unknown as readonly CodecTrait[],
+    },
+    impl: (
+      self: Expression<ScopeField>,
+      needle: unknown,
+    ): Expression<PgBoolReturn> => {
+      const ctx = resolveContext(self, method)
+      gate(ctx, JSON_GATE.capability, JSON_GATE.label, method)
+      requireNonNullOperand(ctx, needle, method)
+      // Reject the empty-object needle: `doc @> '{}'` holds for EVERY
+      // document (jsonb `{} ⊆ anything`), so it would silently return
+      // the whole table. An accidental empty filter is a bug, not a
+      // match-all request (same guard as the drizzle reference).
+      if (
+        needle !== null &&
+        typeof needle === 'object' &&
+        !Array.isArray(needle) &&
+        Object.keys(needle).length === 0
+      ) {
+        throw operatorError(
+          ctx,
+          method,
+          `cipherstash ${method}: an empty object needle on column "${ctx.columnName ?? 'unknown'}" matches every row. Pass a non-empty sub-object, or omit the predicate to select all rows.`,
+        )
+      }
+      const argRef = asQueryTermParam(ctx, needle, method, 'searchableJson')
+      return buildOperation({
+        method,
+        args: [ctx.selfAst, argRef],
+        returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+        lowering: {
+          targetFamily: 'sql',
+          strategy: 'function',
+          template: '{{self}} OPERATOR(public.@>) {{arg0}}::eql_v3.query_jsonb',
+        },
+      })
+    },
+  }
+}
+
+/**
+ * Cipherstash's v3 query-operations contributions. Wired into the v3
+ * runtime descriptor (Task 7's `createCipherstashV3RuntimeDescriptor`)
+ * — and ONLY that descriptor: the method names are shared with the v2
+ * set, and the flat `OperationRegistry` rejects co-registration
+ * (decision 1b; pinned in `test/v3/operator-gating-v3.test.ts`).
+ *
+ * Operator → trait → lowering:
+ *
+ *   - `cipherstashEq` / `cipherstashNe` / `cipherstashInArray` /
+ *     `cipherstashNotInArray` (`cipherstash:equality`) →
+ *     `eql_v3.eq` / `eql_v3.neq` / OR-of-eq
+ *   - `cipherstashGt` / `Gte` / `Lt` / `Lte` / `Between` / `NotBetween`
+ *     (`cipherstash:order-and-range`) → `eql_v3.gt`/`gte`/`lt`/`lte`,
+ *     range as a self-parenthesised `(gte AND lte)` conjunction
+ *   - `cipherstashIlike` / `cipherstashNotIlike`
+ *     (`cipherstash:free-text-search`) → `eql_v3.contains` — a
+ *     bloom-filter TOKEN MATCH (order/multiplicity-insensitive,
+ *     one-sided: may false-positive), NOT SQL ILIKE; the v2 method
+ *     names are kept for surface continuity.
+ *   - `cipherstashJsonContains` (`cipherstash:searchable-json`) →
+ *     exact jsonb containment via `OPERATOR(public.@>)`.
+ *
+ * Every operand renders as `$n::eql_v3.query_<domain>` (irregularly
+ * `::eql_v3.query_jsonb` for JSON), matching the stack-drizzle v3
+ * dialect byte-for-byte.
+ */
+export function cipherstashV3QueryOperations(): SqlOperationDescriptors {
+  return {
+    cipherstashEq: fixedArityOperator(
+      'cipherstashEq',
+      CIPHERSTASH_TRAIT_EQUALITY,
+      1,
+      EQUALITY_GATE,
+      'equality',
+      (cast) => `eql_v3.eq({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashNe: fixedArityOperator(
+      'cipherstashNe',
+      CIPHERSTASH_TRAIT_EQUALITY,
+      1,
+      EQUALITY_GATE,
+      'equality',
+      (cast) => `eql_v3.neq({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashInArray: membershipOperator('cipherstashInArray', false),
+    cipherstashNotInArray: membershipOperator('cipherstashNotInArray', true),
+    cipherstashGt: fixedArityOperator(
+      'cipherstashGt',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      1,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) => `eql_v3.gt({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashGte: fixedArityOperator(
+      'cipherstashGte',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      1,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) => `eql_v3.gte({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashLt: fixedArityOperator(
+      'cipherstashLt',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      1,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) => `eql_v3.lt({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashLte: fixedArityOperator(
+      'cipherstashLte',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      1,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) => `eql_v3.lte({{self}}, {{arg0}}::${cast})`,
+    ),
+    // between's template is a SELF-CONTAINED PARENTHESISED conjunction.
+    // The parens are load-bearing, not cosmetic: Postgres binds NOT
+    // tighter than AND, so an unparenthesised `gte AND lte` under any
+    // generic negation (a framework `not(between(...))`, an OR
+    // composition, …) parses as `(NOT gte) AND lte` — rows BELOW the
+    // lower bound instead of the range complement. Parenthesising here
+    // makes every composition safe instead of relying on each caller.
+    cipherstashBetween: fixedArityOperator(
+      'cipherstashBetween',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      2,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) =>
+        `(eql_v3.gte({{self}}, {{arg0}}::${cast}) AND eql_v3.lte({{self}}, {{arg1}}::${cast}))`,
+    ),
+    cipherstashNotBetween: fixedArityOperator(
+      'cipherstashNotBetween',
+      CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+      2,
+      ORDERING_GATE,
+      'orderAndRange',
+      (cast) =>
+        `NOT (eql_v3.gte({{self}}, {{arg0}}::${cast}) AND eql_v3.lte({{self}}, {{arg1}}::${cast}))`,
+    ),
+    // ilike/notIlike lower to eql_v3.contains — bloom-filter token
+    // matching, NOT SQL ILIKE (may false-positive; carry this caveat
+    // into user docs).
+    cipherstashIlike: fixedArityOperator(
+      'cipherstashIlike',
+      CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+      1,
+      FREE_TEXT_GATE,
+      'freeTextSearch',
+      (cast) => `eql_v3.contains({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashNotIlike: fixedArityOperator(
+      'cipherstashNotIlike',
+      CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+      1,
+      FREE_TEXT_GATE,
+      'freeTextSearch',
+      (cast) => `NOT eql_v3.contains({{self}}, {{arg0}}::${cast})`,
+    ),
+    cipherstashJsonContains: jsonContainsOperator(),
+  }
+}
+
+/**
+ * Build the encrypted order-term extractor expression for a column:
+ * `eql_v3.ord_term(col)` for OPE-backed `_ord` domains (and
+ * `text_search`), `eql_v3.ord_term_ore(col)` for block-ORE `_ord_ore`
+ * domains — eql-3.0.0 splits the extractor by term flavour, keyed off
+ * the column's own index set (matching the drizzle reference's
+ * `orderBy` dialect).
+ *
+ * The expression's declared return codec is the COLUMN's codec ref.
+ * The extractor's real SQL type is an internal ordering term
+ * (`eql_v3_internal.*`) that no codec models; the value is only ever
+ * consumed positionally inside ORDER BY (never projected or bound), so
+ * the return-type slot is type-level plumbing only.
+ */
+function ordTermExpression(
+  col: Expression<ScopeField>,
+  method: string,
+): Expression<ScopeField> {
+  const ctx = resolveContext(col, method)
+  gate(ctx, ORDERING_GATE.capability, ORDERING_GATE.label, method)
+  const fn = ctx.meta.indexes.ore ? 'ord_term_ore' : 'ord_term'
+  return buildOperation({
+    method,
+    args: [ctx.selfAst],
+    returns: { codecId: ctx.selfCodec.codecId, nullable: true },
+    lowering: {
+      targetFamily: 'sql',
+      strategy: 'function',
+      template: `eql_v3.${fn}({{self}})`,
+    },
+  })
+}
+
+/**
+ * ASC sort over an order-capable v3 column, via the encrypted
+ * order-term extractor: `ORDER BY eql_v3.ord_term(col) ASC` (or
+ * `ord_term_ore` on a block-ORE domain).
+ *
+ * A free-standing helper, not a registered operator — same rationale
+ * as the v2 `cipherstashAsc`: sort returns an `OrderByItem`, not the
+ * boolean predicate the registry's where-binding pipeline expects. The
+ * `V3` suffix keeps the export distinct from the v2 helper (unlike
+ * registry method names, free-standing exports share one barrel
+ * namespace). Unlike v2 (bare-column sort over `eql_v2_encrypted`'s
+ * native operator family), v3 domains have no cross-row comparison
+ * operators — sorting MUST extract the order term. Synchronous: no
+ * operand, so no query term is minted.
+ */
+export function cipherstashV3Asc(col: Expression<ScopeField>): OrderByItem {
+  return OrderByItem.asc(ordTermExpression(col, 'cipherstashV3Asc').buildAst())
+}
+
+/**
+ * DESC sort over an order-capable v3 column. See {@link cipherstashV3Asc}.
+ */
+export function cipherstashV3Desc(col: Expression<ScopeField>): OrderByItem {
+  return OrderByItem.desc(
+    ordTermExpression(col, 'cipherstashV3Desc').buildAst(),
+  )
+}
diff --git a/packages/prisma-next/test/equality-trait-removal.test.ts b/packages/prisma-next/test/equality-trait-removal.test.ts
index bc85458e..d131fe01 100644
--- a/packages/prisma-next/test/equality-trait-removal.test.ts
+++ b/packages/prisma-next/test/equality-trait-removal.test.ts
@@ -36,6 +36,7 @@ import { createCipherstashStringCodec } from '../src/execution/codec-runtime'
 import { createParameterizedCodecDescriptors } from '../src/execution/parameterized'
 import type { CipherstashSdk } from '../src/execution/sdk'
 import { cipherstashStringCodecMetadata } from '../src/extension-metadata/codec-metadata'
+import { createV3CodecDescriptors } from '../src/v3/codec-runtime-v3'
 
 function emptySdk(): CipherstashSdk {
   return {
@@ -90,6 +91,26 @@ describe('cipherstash codec: no `equality` trait', () => {
   })
 })
 
+describe('cipherstash v3 codec descriptors: no framework built-in traits', () => {
+  it('every v3 descriptor advertises only cipherstash:* traits — never the framework built-in `equality`', () => {
+    // Same footgun as v2, per-domain: a framework built-in trait on a
+    // v3 codec descriptor would re-attach the built-in `eq` (SQL `=`)
+    // to encrypted columns, which silently returns zero rows against
+    // nondeterministic ciphertexts. Storage-only domains legitimately
+    // carry an EMPTY trait list (they answer no operator at all), so
+    // the invariant is subset-of-`cipherstash:*`, not non-empty.
+    const descriptors = createV3CodecDescriptors(emptySdk())
+    expect(descriptors.length).toBeGreaterThan(0)
+    for (const descriptor of descriptors) {
+      const traits: ReadonlyArray<string> = descriptor.traits ?? []
+      for (const trait of traits) {
+        expect(String(trait).startsWith('cipherstash:')).toBe(true)
+      }
+      expect(traits).not.toContain('equality')
+    }
+  })
+})
+
 describe('cipherstash columns: framework built-in `eq` is not reachable', () => {
   it('documents the gating contract — built-in `eq` requires `equality` in column traits', () => {
     // This test pins the contract that `cipherstash/string@1` columns
diff --git a/packages/prisma-next/test/v3/operator-gating-v3.test.ts b/packages/prisma-next/test/v3/operator-gating-v3.test.ts
new file mode 100644
index 00000000..97dcaf57
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-gating-v3.test.ts
@@ -0,0 +1,193 @@
+/**
+ * v3 operator capability gating + registration constraints.
+ *
+ * Every v3 operator gates on the CONCRETE domain's query capabilities
+ * (derived from the catalog by codec id) before building any AST, and
+ * throws `EncryptionOperatorError` naming the column, domain, operator,
+ * and missing capability. Trait dispatch alone is not enough: traits
+ * are per-codec, and a caller reaching the operator descriptor directly
+ * (or through a custom builder) must still be stopped when the domain
+ * cannot answer the operator.
+ *
+ * Also pins decision 1b's registration constraint: the v3 descriptor
+ * stands alone (a v3-only adapter builds cleanly), and co-registering
+ * the v2 and v3 descriptors throws — the framework's flat
+ * `OperationRegistry` rejects two descriptors sharing the
+ * `cipherstashEq` method name. v2 and v3 are separate entry points,
+ * never composed into one client.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createCipherstashRuntimeDescriptor } from '../../src/exports/runtime'
+import {
+  cipherstashV3Asc,
+  cipherstashV3QueryOperations,
+  EncryptionOperatorError,
+} from '../../src/v3/operators-v3'
+import {
+  assembleV3ExecutionContext,
+  BOOLEAN_CODEC_ID,
+  callOperator,
+  columnAccessorV3,
+  emptySdk,
+  getOperator,
+  JSON_CODEC_ID,
+  makeV3Adapter,
+  TABLE,
+  TEXT_EQ_CODEC_ID,
+  TEXT_STORAGE_CODEC_ID,
+  v3RuntimeDescriptor,
+} from './operator-lowering-v3.helpers'
+
+describe('v3 operator capability gating', () => {
+  it('equality requires the equality capability — storage-only eql_v3_text rejects cipherstashEq', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'note', TEXT_STORAGE_CODEC_ID),
+        'x',
+      ),
+    ).toThrow(EncryptionOperatorError)
+  })
+
+  it('names the column, domain, operator, and missing capability in the diagnostic', () => {
+    try {
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'note', TEXT_STORAGE_CODEC_ID),
+        'x',
+      )
+      expect.unreachable('cipherstashEq on a storage-only column must throw')
+    } catch (error) {
+      expect(error).toBeInstanceOf(EncryptionOperatorError)
+      const operatorError = error as EncryptionOperatorError
+      expect(operatorError.message).toContain('cipherstashEq')
+      expect(operatorError.message).toContain('equality')
+      expect(operatorError.message).toContain('"note"')
+      expect(operatorError.message).toContain('public.eql_v3_text')
+      expect(operatorError.context).toEqual({
+        columnName: 'note',
+        tableName: TABLE,
+        operator: 'cipherstashEq',
+      })
+    }
+  })
+
+  it('comparison requires order/range — text_eq rejects cipherstashGt', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashGt'),
+        columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
+        'x',
+      ),
+    ).toThrow(/order\/range/)
+  })
+
+  it('free-text requires the match index — text_eq rejects cipherstashIlike', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashIlike'),
+        columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
+        'x',
+      ),
+    ).toThrow(/free-text/)
+  })
+
+  it('JSON containment requires searchableJson — text_eq rejects cipherstashJsonContains', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashJsonContains'),
+        columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
+        { role: 'admin' },
+      ),
+    ).toThrow(/JSON containment/)
+  })
+
+  it('eql_v3_json is searchableJson-only — rejects cipherstashEq', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+        { role: 'admin' },
+      ),
+    ).toThrow(/equality/)
+  })
+
+  it('storage-only eql_v3_boolean rejects every search operator', () => {
+    for (const method of [
+      'cipherstashEq',
+      'cipherstashNe',
+      'cipherstashGt',
+      'cipherstashIlike',
+      'cipherstashJsonContains',
+    ]) {
+      expect(() =>
+        callOperator(
+          getOperator(method),
+          columnAccessorV3(TABLE, 'active', BOOLEAN_CODEC_ID),
+          true,
+        ),
+      ).toThrow(EncryptionOperatorError)
+    }
+  })
+
+  it('ordering helpers gate on order/range — text_eq rejects cipherstashV3Asc', () => {
+    expect(() =>
+      cipherstashV3Asc(columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID)),
+    ).toThrow(/order\/range/)
+  })
+
+  it('rejects a non-v3 codec id (v2 columns are the wrong entry point)', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'email', 'cipherstash/string@1'),
+        'x',
+      ),
+    ).toThrow(/not a .*v3 domain/)
+  })
+
+  it('rejects a self expression with no codec binding', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        {
+          buildAst: () => {
+            throw new Error('unreachable')
+          },
+        },
+        'x',
+      ),
+    ).toThrow(/missing a CodecRef/)
+  })
+})
+
+describe('v3 descriptor registration (decision 1b)', () => {
+  it('a v3-only adapter builds and registers its operation set cleanly', () => {
+    expect(() => makeV3Adapter()).not.toThrow()
+    // The execution context is what assembles the flat operation
+    // registry from `queryOperations()` — a v3-only stack registers the
+    // full `cipherstash*` method set without collision.
+    const registered = Object.keys(
+      assembleV3ExecutionContext().queryOperations.entries(),
+    )
+    expect(registered).toEqual(
+      expect.arrayContaining([...Object.keys(cipherstashV3QueryOperations())]),
+    )
+  })
+
+  it('co-registering the v2 and v3 descriptors throws on the shared method names', () => {
+    // Both descriptors define `cipherstashEq` (and eleven siblings); the
+    // flat, method-keyed OperationRegistry disallows override. This is
+    // WHY v2 and v3 are separate entry points that are never composed
+    // into one client. The registry is assembled when the execution
+    // context is built against a contract, so the collision surfaces
+    // there rather than at adapter construction.
+    expect(() =>
+      assembleV3ExecutionContext([
+        createCipherstashRuntimeDescriptor({ sdk: emptySdk() }),
+        v3RuntimeDescriptor(),
+      ]),
+    ).toThrow(/already registered/)
+  })
+})
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
new file mode 100644
index 00000000..35a87496
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
@@ -0,0 +1,243 @@
+/**
+ * v3 operator lowering — equality family (`cipherstashEq`,
+ * `cipherstashNe`, `cipherstashInArray`, `cipherstashNotInArray`).
+ *
+ * The canonical v3 dialect (mirrors
+ * `packages/stack-drizzle/src/v3/{operators,sql-dialect}.ts`):
+ * operands are QUERY TERMS cast to the column domain's
+ * `eql_v3.query_<domain>` type —
+ *
+ *     eql_v3.eq(<col>, $n::eql_v3.query_<domain>)
+ *     eql_v3.neq(<col>, $n::eql_v3.query_<domain>)
+ *
+ * The cast is what reaches the bundle's `(domain, query_<domain>)`
+ * overloads — the storage-domain overload's CHECK demands the
+ * ciphertext `c` a query term deliberately omits. The bound param is
+ * an `Encrypted*` envelope stamped with the `(table, column)` routing
+ * key AND a query-term type mark (`'equality'`) so Task 7's SDK
+ * boundary encrypts it via `encryptQuery` (a ciphertext-free term),
+ * never the storage `bulkEncrypt` path.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import {
+  EncryptionOperatorError,
+  v3QueryTermTypeOf,
+} from '../../src/v3/operators-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  contractV3,
+  getOperator,
+  INTEGER_ORD_CODEC_ID,
+  literalParamValue,
+  makeV3Adapter,
+  selectWithWhere,
+  TABLE,
+  TEXT_EQ_CODEC_ID,
+  TEXT_SEARCH_CODEC_ID,
+} from './operator-lowering-v3.helpers'
+
+describe('cipherstash v3 operator lowering — cipherstashEq', () => {
+  it('lowers nickname.cipherstashEq(plaintext) to eql_v3.eq(col, $1::eql_v3.query_text_eq)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashEq'),
+      columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
+      'alice',
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.eq("user"."nickname", $1::eql_v3.query_text_eq)"`,
+    )
+  })
+
+  it('lowers email.cipherstashEq on a text_search column with the query_text_search cast', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashEq'),
+      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
+      'alice@example.com',
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.eq("user"."email", $1::eql_v3.query_text_search)"`,
+    )
+  })
+
+  it('accepts equality on an OPE-ordered domain (integer_ord answers equality via its ordering term)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashEq'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      42,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.eq("user"."score", $1::eql_v3.query_integer_ord)"`,
+    )
+  })
+
+  it('binds the plaintext as an envelope stamped with the routing key and the equality query-term mark', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashEq'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      42,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.params).toHaveLength(1)
+    const envelope = literalParamValue(lowered.params[0])
+    expect(envelope).toBeInstanceOf(EncryptedNumber)
+    const handle = (envelope as EncryptedNumber).expose()
+    expect(handle.plaintext).toBe(42)
+    expect(handle.table).toBe(TABLE)
+    expect(handle.column).toBe('score')
+    // The seam Task 7's SDK adapter consumes: this operand must be
+    // encrypted as an `encryptQuery` term (queryType 'equality'), not
+    // storage-encrypted.
+    expect(v3QueryTermTypeOf(envelope as EncryptedNumber)).toBe('equality')
+  })
+
+  it('passes a pre-built envelope through unchanged (advanced caller path)', () => {
+    const userEnvelope = EncryptedString.from('alice')
+    const predicate = callOperator(
+      getOperator('cipherstashEq'),
+      columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
+      userEnvelope,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(literalParamValue(lowered.params[0])).toBe(userEnvelope)
+    const handle = userEnvelope.expose()
+    expect(handle.table).toBe(TABLE)
+    expect(handle.column).toBe('nickname')
+    expect(v3QueryTermTypeOf(userEnvelope)).toBe('equality')
+  })
+
+  it('rejects a plaintext that does not match the domain castAs with a specific diagnostic', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        'not-a-number',
+      ),
+    ).toThrow(EncryptionOperatorError)
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        'not-a-number',
+      ),
+    ).toThrow(/number/)
+  })
+
+  it('rejects a null operand with an isNull() hint', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        null,
+      ),
+    ).toThrow(/isNull/)
+  })
+})
+
+describe('cipherstash v3 operator lowering — cipherstashNe', () => {
+  it('lowers to eql_v3.neq(col, $1::eql_v3.query_<domain>)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashNe'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      42,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.neq("user"."score", $1::eql_v3.query_integer_ord)"`,
+    )
+    expect(v3QueryTermTypeOf(literalParamValue(lowered.params[0]))).toBe(
+      'equality',
+    )
+  })
+})
+
+describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashNotInArray', () => {
+  it('lowers a single-element inArray to a one-term OR (outer parens retained)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashInArray'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      [1],
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE (eql_v3.eq("user"."score", $1::eql_v3.query_integer_ord))"`,
+    )
+  })
+
+  it('lowers a two-element inArray to an OR of eq terms, one query-term param per value', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashInArray'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      [1, 2],
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE (eql_v3.eq("user"."score", $1::eql_v3.query_integer_ord) OR eql_v3.eq("user"."score", $2::eql_v3.query_integer_ord))"`,
+    )
+    expect(lowered.params).toHaveLength(2)
+    for (const param of lowered.params) {
+      const envelope = literalParamValue(param)
+      expect(envelope).toBeInstanceOf(EncryptedNumber)
+      const handle = (envelope as EncryptedNumber).expose()
+      expect(handle.table).toBe(TABLE)
+      expect(handle.column).toBe('score')
+      expect(v3QueryTermTypeOf(envelope as EncryptedNumber)).toBe('equality')
+    }
+  })
+
+  it('lowers cipherstashNotInArray to NOT-prefixed OR-of-equalities (whole disjunction negated)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashNotInArray'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      [1, 2],
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE NOT (eql_v3.eq("user"."score", $1::eql_v3.query_integer_ord) OR eql_v3.eq("user"."score", $2::eql_v3.query_integer_ord))"`,
+    )
+  })
+
+  it('rejects empty arrays with a descriptive error', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashInArray'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        [],
+      ),
+    ).toThrow(/empty array/)
+  })
+
+  it('rejects non-array arguments with a descriptive error', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashInArray'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        'not-an-array',
+      ),
+    ).toThrow(/expected an array/)
+  })
+})
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
new file mode 100644
index 00000000..7220d177
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
@@ -0,0 +1,98 @@
+/**
+ * v3 operator lowering — encrypted-JSONB containment
+ * (`cipherstashJsonContains`, trait `cipherstash:searchable-json`).
+ *
+ * Canonical dialect (mirrors `v3Dialect.containsJson` in
+ * `packages/stack-drizzle/src/v3/sql-dialect.ts`): `eql_v3_json` has NO
+ * `eql_v3.contains` overload — containment is the `@>` operator, whose
+ * `(eql_v3_json, eql_v3.query_jsonb)` form takes a NARROWED query term
+ * (searchableJson → no ciphertext) cast to the irregular
+ * `eql_v3.query_jsonb` type:
+ *
+ *     <col> OPERATOR(public.@>) $n::eql_v3.query_jsonb
+ *
+ * The four `eql_v3_json @> ?` RHS overloads mean a bare operand would
+ * be ambiguous ("operator is not unique", 42725) — the explicit cast
+ * is load-bearing.
+ *
+ * Unlike the bloom `cipherstashIlike`, this is EXACT jsonb containment:
+ * no false positives. This is the drizzle reference's full JSON
+ * operator surface (`contains`); the reference exposes neither a
+ * containedBy direction nor selector querying, so neither is
+ * registered here.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import {
+  EncryptionOperatorError,
+  v3QueryTermTypeOf,
+} from '../../src/v3/operators-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  contractV3,
+  getOperator,
+  JSON_CODEC_ID,
+  literalParamValue,
+  makeV3Adapter,
+  selectWithWhere,
+  TABLE,
+} from './operator-lowering-v3.helpers'
+
+describe('cipherstash v3 operator lowering — cipherstashJsonContains', () => {
+  it('lowers to col OPERATOR(public.@>) $1::eql_v3.query_jsonb', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashJsonContains'),
+      columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+      { role: 'admin' },
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE "user"."payload" OPERATOR(public.@>) $1::eql_v3.query_jsonb"`,
+    )
+  })
+
+  it('binds the needle as an EncryptedJson envelope with the searchableJson query-term mark', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashJsonContains'),
+      columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+      { role: 'admin' },
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.params).toHaveLength(1)
+    const envelope = literalParamValue(lowered.params[0])
+    expect(envelope).toBeInstanceOf(EncryptedJson)
+    const handle = (envelope as EncryptedJson).expose()
+    expect(handle.plaintext).toEqual({ role: 'admin' })
+    expect(handle.table).toBe(TABLE)
+    expect(handle.column).toBe('payload')
+    expect(v3QueryTermTypeOf(envelope as EncryptedJson)).toBe('searchableJson')
+  })
+
+  it('rejects the empty-object needle (it matches every row)', () => {
+    // `doc @> '{}'` holds for EVERY document (jsonb `{} ⊆ anything`) —
+    // the same whole-table footgun the drizzle reference guards.
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashJsonContains'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+        {},
+      ),
+    ).toThrow(/matches every row/)
+  })
+
+  it('rejects a null needle with an isNull() hint', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashJsonContains'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+        null,
+      ),
+    ).toThrow(EncryptionOperatorError)
+  })
+})
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
new file mode 100644
index 00000000..b7ef6d89
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
@@ -0,0 +1,160 @@
+/**
+ * v3 operator lowering — order/range family (`cipherstashGt` / `Gte` /
+ * `Lt` / `Lte` / `Between` / `NotBetween`) plus the free-standing
+ * ordering helpers (`cipherstashV3Asc` / `cipherstashV3Desc`).
+ *
+ * Canonical dialect (mirrors `packages/stack-drizzle/src/v3/sql-dialect.ts`):
+ *
+ *     eql_v3.gt(<col>, $n::eql_v3.query_<domain>)
+ *     (eql_v3.gte(...) AND eql_v3.lte(...))          -- between, self-parenthesised
+ *     NOT (eql_v3.gte(...) AND eql_v3.lte(...))      -- notBetween
+ *     ORDER BY eql_v3.ord_term(<col>)                -- OPE `_ord` domains
+ *     ORDER BY eql_v3.ord_term_ore(<col>)            -- block-ORE `_ord_ore` domains
+ *
+ * `between`'s parentheses are load-bearing, not cosmetic: Postgres
+ * binds NOT tighter than AND, so an unparenthesised `gte AND lte`
+ * under a generic negation parses as `(NOT gte) AND lte` — rows BELOW
+ * the lower bound instead of the range complement.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { EncryptedBigInt } from '../../src/execution/envelope-bigint'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import {
+  cipherstashV3Asc,
+  cipherstashV3Desc,
+  v3QueryTermTypeOf,
+} from '../../src/v3/operators-v3'
+import {
+  BIGINT_ORD_ORE_CODEC_ID,
+  callOperator,
+  columnAccessorV3,
+  contractV3,
+  getOperator,
+  INTEGER_ORD_CODEC_ID,
+  literalParamValue,
+  makeV3Adapter,
+  selectWithOrderBy,
+  selectWithWhere,
+  TABLE,
+} from './operator-lowering-v3.helpers'
+
+describe('cipherstash v3 operator lowering — comparisons', () => {
+  it.each([
+    ['cipherstashGt', 'gt'],
+    ['cipherstashGte', 'gte'],
+    ['cipherstashLt', 'lt'],
+    ['cipherstashLte', 'lte'],
+  ] as const)('%s lowers to eql_v3.%s(col, $1::eql_v3.query_integer_ord)', (method, fn) => {
+    const predicate = callOperator(
+      getOperator(method),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      10,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toBe(
+      `SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.${fn}("user"."score", $1::eql_v3.query_integer_ord)`,
+    )
+    const envelope = literalParamValue(lowered.params[0])
+    expect(envelope).toBeInstanceOf(EncryptedNumber)
+    expect(v3QueryTermTypeOf(envelope as EncryptedNumber)).toBe('orderAndRange')
+  })
+
+  it('casts to the ord_ore query domain on a block-ORE column (bigint envelope dispatch)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashGt'),
+      columnAccessorV3(TABLE, 'balance', BIGINT_ORD_ORE_CODEC_ID),
+      100n,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.gt("user"."balance", $1::eql_v3.query_bigint_ord_ore)"`,
+    )
+    expect(literalParamValue(lowered.params[0])).toBeInstanceOf(EncryptedBigInt)
+  })
+})
+
+describe('cipherstash v3 operator lowering — between / notBetween', () => {
+  it('cipherstashBetween is a SELF-PARENTHESISED conjunction (composition-safe)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashBetween'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      1,
+      9,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE (eql_v3.gte("user"."score", $1::eql_v3.query_integer_ord) AND eql_v3.lte("user"."score", $2::eql_v3.query_integer_ord))"`,
+    )
+    expect(lowered.params).toHaveLength(2)
+    expect(
+      (literalParamValue(lowered.params[0]) as EncryptedNumber).expose()
+        .plaintext,
+    ).toBe(1)
+    expect(
+      (literalParamValue(lowered.params[1]) as EncryptedNumber).expose()
+        .plaintext,
+    ).toBe(9)
+  })
+
+  it('cipherstashNotBetween wraps the WHOLE conjunction: NOT (gte AND lte)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashNotBetween'),
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+      1,
+      9,
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE NOT (eql_v3.gte("user"."score", $1::eql_v3.query_integer_ord) AND eql_v3.lte("user"."score", $2::eql_v3.query_integer_ord))"`,
+    )
+    // Regression guard on the `NOT gte AND lte` degradation: the NOT
+    // must never bind to the gte term alone.
+    expect(lowered.sql).not.toMatch(/NOT eql_v3\.gte/)
+  })
+
+  it('cipherstashBetween enforces its 2-argument arity', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashBetween'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        1,
+      ),
+    ).toThrow(/expected 2 argument/)
+  })
+})
+
+describe('cipherstash v3 ordering — cipherstashV3Asc / cipherstashV3Desc', () => {
+  it('lowers ASC on an OPE `_ord` column to ORDER BY eql_v3.ord_term(col) ASC', () => {
+    const item = cipherstashV3Asc(
+      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+    )
+    const lowered = makeV3Adapter().lower(selectWithOrderBy([item]), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" ORDER BY eql_v3.ord_term("user"."score") ASC"`,
+    )
+    expect(lowered.params).toHaveLength(0)
+  })
+
+  it('lowers DESC on a block-ORE `_ord_ore` column to ORDER BY eql_v3.ord_term_ore(col) DESC', () => {
+    const item = cipherstashV3Desc(
+      columnAccessorV3(TABLE, 'balance', BIGINT_ORD_ORE_CODEC_ID),
+    )
+    const lowered = makeV3Adapter().lower(selectWithOrderBy([item]), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" ORDER BY eql_v3.ord_term_ore("user"."balance") DESC"`,
+    )
+  })
+})
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
new file mode 100644
index 00000000..0bf0916b
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
@@ -0,0 +1,82 @@
+/**
+ * v3 operator lowering — free-text search family (`cipherstashIlike` /
+ * `cipherstashNotIlike`).
+ *
+ * Canonical dialect: `eql_v3.contains(<col>, $n::eql_v3.query_<domain>)`.
+ * The SQL function keeps its bundle name `contains`, but the semantics
+ * are a bloom-filter TOKEN MATCH, not SQL LIKE/ILIKE and not
+ * containment: the needle's downcased 3-gram set is tested as a subset
+ * of the haystack's — order- and multiplicity-insensitive, and
+ * one-sided (a `true` may be a false positive; a `false` never is).
+ * The method names stay `cipherstashIlike` / `cipherstashNotIlike` to
+ * mirror the v2 operator surface (decision 1b — same method names, v3
+ * descriptor only).
+ */
+
+import { describe, expect, it } from 'vitest'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { v3QueryTermTypeOf } from '../../src/v3/operators-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  contractV3,
+  getOperator,
+  literalParamValue,
+  makeV3Adapter,
+  selectWithWhere,
+  TABLE,
+  TEXT_SEARCH_CODEC_ID,
+} from './operator-lowering-v3.helpers'
+
+describe('cipherstash v3 operator lowering — cipherstashIlike', () => {
+  it('lowers to eql_v3.contains(col, $1::eql_v3.query_text_search)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashIlike'),
+      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
+      'alice',
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.contains("user"."email", $1::eql_v3.query_text_search)"`,
+    )
+  })
+
+  it('binds the needle as an EncryptedString envelope with the freeTextSearch query-term mark', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashIlike'),
+      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
+      'alice',
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.params).toHaveLength(1)
+    const envelope = literalParamValue(lowered.params[0])
+    expect(envelope).toBeInstanceOf(EncryptedString)
+    const handle = (envelope as EncryptedString).expose()
+    expect(handle.plaintext).toBe('alice')
+    expect(handle.table).toBe(TABLE)
+    expect(handle.column).toBe('email')
+    expect(v3QueryTermTypeOf(envelope as EncryptedString)).toBe(
+      'freeTextSearch',
+    )
+  })
+})
+
+describe('cipherstash v3 operator lowering — cipherstashNotIlike', () => {
+  it('lowers to NOT eql_v3.contains(col, $1::eql_v3.query_text_search)', () => {
+    const predicate = callOperator(
+      getOperator('cipherstashNotIlike'),
+      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
+      'alice',
+    )
+    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
+      contract: contractV3,
+    })
+    expect(lowered.sql).toMatchInlineSnapshot(
+      `"SELECT "user"."id" AS "id" FROM "user" WHERE NOT eql_v3.contains("user"."email", $1::eql_v3.query_text_search)"`,
+    )
+  })
+})
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts b/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts
new file mode 100644
index 00000000..8bfd2438
--- /dev/null
+++ b/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts
@@ -0,0 +1,293 @@
+/**
+ * Shared scaffolding for the `operator-lowering-v3*.test.ts` files —
+ * the v3 twin of `../operator-lowering.helpers.ts`.
+ *
+ * Differences from the v2 helper, both deliberate:
+ *
+ *   - **Runtime pack**: composes a v3-only extension descriptor built
+ *     inline from `createV3CodecDescriptors` + `cipherstashV3QueryOperations`
+ *     under v3's OWN extension id (`CIPHERSTASH_V3_SPACE_ID`). Task 7's
+ *     `createCipherstashV3RuntimeDescriptor` will productionise this
+ *     exact shape; the inline copy keeps the operator tests decoupled
+ *     from that task. The v2 descriptor is NEVER co-registered here —
+ *     decision 1b (the flat `OperationRegistry` rejects two descriptors
+ *     sharing the `cipherstashEq` method name; pinned in
+ *     `operator-gating-v3.test.ts`).
+ *   - **Contract columns**: each v3 column carries its concrete
+ *     `public.eql_v3_*` domain as `nativeType` plus the
+ *     `{ castAs, capabilities }` typeParams block v3 authoring emits —
+ *     derived from the catalog so the fixture cannot drift from the
+ *     GA domain registry.
+ */
+
+import postgresRuntimeAdapter from '@prisma-next/adapter-postgres/runtime'
+import type { PostgresContract } from '@prisma-next/adapter-postgres/types'
+import type { RuntimeTargetDescriptor } from '@prisma-next/framework-components/execution'
+import { validateSqlContractFully } from '@prisma-next/sql-contract/validators'
+import type { SqlOperationDescriptor } from '@prisma-next/sql-operations'
+import {
+  type AnyExpression,
+  ColumnRef,
+  type LoweredParam,
+  type OrderByItem,
+  ProjectionItem,
+  SelectAst,
+  TableSource,
+} from '@prisma-next/sql-relational-core/ast'
+import {
+  createExecutionContext,
+  createSqlExecutionStack,
+  type SqlRuntimeExtensionDescriptor,
+} from '@prisma-next/sql-runtime'
+import { vi } from 'vitest'
+import type { CipherstashSdk } from '../../src/execution/sdk'
+import {
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_SPACE_ID,
+} from '../../src/extension-metadata/constants-v3'
+import { V3_DOMAIN_META_BY_CODEC_ID } from '../../src/v3/catalog'
+import { createV3CodecDescriptors } from '../../src/v3/codec-runtime-v3'
+import { cipherstashV3QueryOperations } from '../../src/v3/operators-v3'
+
+// Minimal SDK stub. Operator lowering doesn't talk to the SDK — the codec
+// captures it lazily for the read-side decrypt path — but the codec
+// descriptors require one.
+export function emptySdk(): CipherstashSdk {
+  return {
+    decrypt: vi.fn(),
+    bulkEncrypt: vi.fn(),
+    bulkDecrypt: vi.fn(),
+  }
+}
+
+export const TABLE = 'user'
+
+// GA codec ids (registry key VERBATIM — never strip the `eql_v3_` prefix).
+export const TEXT_SEARCH_CODEC_ID = 'cipherstash/eql-v3/eql_v3_text_search@1'
+export const TEXT_EQ_CODEC_ID = 'cipherstash/eql-v3/eql_v3_text_eq@1'
+export const TEXT_STORAGE_CODEC_ID = 'cipherstash/eql-v3/eql_v3_text@1'
+export const INTEGER_ORD_CODEC_ID = 'cipherstash/eql-v3/eql_v3_integer_ord@1'
+export const BIGINT_ORD_ORE_CODEC_ID =
+  'cipherstash/eql-v3/eql_v3_bigint_ord_ore@1'
+export const DATE_ORD_CODEC_ID = 'cipherstash/eql-v3/eql_v3_date_ord@1'
+export const BOOLEAN_CODEC_ID = 'cipherstash/eql-v3/eql_v3_boolean@1'
+export const JSON_CODEC_ID = 'cipherstash/eql-v3/eql_v3_json@1'
+
+/**
+ * Build a contract column entry for a v3 codec id, deriving `nativeType`
+ * (the concrete `public.eql_v3_*` domain) and the `{ castAs, capabilities }`
+ * typeParams block from the catalog so the fixture is always truthful to
+ * the GA registry.
+ */
+function v3Column(codecId: string) {
+  const meta = V3_DOMAIN_META_BY_CODEC_ID.get(codecId)
+  if (!meta) {
+    throw new Error(`operator-lowering-v3 helpers: unknown codec id ${codecId}`)
+  }
+  return {
+    codecId,
+    nativeType: meta.nativeType,
+    nullable: true,
+    typeParams: { castAs: meta.castAs, capabilities: meta.capabilities },
+  }
+}
+
+export const contractV3 = validateSqlContractFully<PostgresContract>({
+  target: 'postgres',
+  targetFamily: 'sql',
+  profileHash: 'sha256:cipherstash-operator-lowering-v3-test',
+  roots: {},
+  capabilities: {},
+  extensionPacks: {},
+  meta: {},
+  storage: {
+    storageHash: 'sha256:cipherstash-operator-lowering-v3-test-storage',
+    namespaces: {
+      __unbound__: {
+        id: '__unbound__',
+        entries: {
+          table: {
+            [TABLE]: {
+              columns: {
+                id: {
+                  codecId: 'pg/text@1',
+                  nativeType: 'text',
+                  nullable: false,
+                },
+                // One column per capability family so every operator can
+                // be exercised against a domain that supports it (and a
+                // domain that doesn't, for the gating tests).
+                email: v3Column(TEXT_SEARCH_CODEC_ID), // match + ope + unique
+                nickname: v3Column(TEXT_EQ_CODEC_ID), // unique only
+                note: v3Column(TEXT_STORAGE_CODEC_ID), // storage-only
+                score: v3Column(INTEGER_ORD_CODEC_ID), // ope (OPE ordering)
+                balance: v3Column(BIGINT_ORD_ORE_CODEC_ID), // ore (block-ORE)
+                birthday: v3Column(DATE_ORD_CODEC_ID), // ope
+                active: v3Column(BOOLEAN_CODEC_ID), // storage-only
+                payload: v3Column(JSON_CODEC_ID), // ste_vec
+              },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [],
+            },
+          },
+        },
+      },
+    },
+  },
+  domain: { namespaces: { __unbound__: { models: {} } } },
+})
+
+// Stub runtime target — the Postgres adapter only consults `familyId` /
+// `targetId` on the target during `create`. Same inline replica as the
+// v2 helper (no postgres-package test-export dependency). The empty
+// `codecs` contribution mirrors the real
+// `@prisma-next/target-postgres/runtime` descriptor (the target
+// contributes no codecs; they ship from the adapter and extension
+// packs) and is required by `createExecutionContext`'s contributor
+// walk in `assembleV3ExecutionContext`.
+const stubRuntimeTarget: RuntimeTargetDescriptor<'sql', 'postgres'> & {
+  readonly codecs: () => readonly never[]
+} = {
+  kind: 'target',
+  id: 'postgres',
+  version: '0.0.1',
+  familyId: 'sql',
+  targetId: 'postgres',
+  codecs: () => [],
+  create() {
+    return { familyId: 'sql', targetId: 'postgres' }
+  },
+}
+
+/**
+ * The v3-only runtime extension descriptor — the shape Task 7's
+ * `createCipherstashV3RuntimeDescriptor` will export, composed inline
+ * so the operator tests don't depend on that task. Registered under
+ * v3's own distinct extension id (decision 1b).
+ */
+export function v3RuntimeDescriptor(
+  sdk: CipherstashSdk = emptySdk(),
+): SqlRuntimeExtensionDescriptor<'postgres'> {
+  const descriptors = createV3CodecDescriptors(sdk)
+  return {
+    kind: 'extension' as const,
+    id: CIPHERSTASH_V3_SPACE_ID,
+    version: CIPHERSTASH_V3_EXTENSION_VERSION,
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    types: { codecTypes: { codecDescriptors: descriptors } },
+    codecs: () => descriptors,
+    queryOperations: () => cipherstashV3QueryOperations(),
+    create() {
+      return { familyId: 'sql' as const, targetId: 'postgres' as const }
+    },
+  }
+}
+
+export function makeV3Adapter(
+  extensionPacks: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>> = [
+    v3RuntimeDescriptor(),
+  ],
+) {
+  return postgresRuntimeAdapter.create({
+    target: stubRuntimeTarget,
+    adapter: postgresRuntimeAdapter,
+    driver: undefined,
+    extensionPacks: [...extensionPacks],
+  })
+}
+
+/**
+ * Assemble a full SQL execution context (contract + stack) — the step
+ * that builds the flat `OperationRegistry` from every contributor's
+ * `queryOperations()`. This is where a duplicate method name across
+ * extension packs throws (`adapter.lower` alone never touches the
+ * registry), so the decision-1b co-registration pin drives this path.
+ */
+export function assembleV3ExecutionContext(
+  extensionPacks: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>> = [
+    v3RuntimeDescriptor(),
+  ],
+) {
+  return createExecutionContext({
+    contract: contractV3,
+    stack: createSqlExecutionStack({
+      target: stubRuntimeTarget,
+      adapter: postgresRuntimeAdapter,
+      extensionPacks: [...extensionPacks],
+    }),
+  })
+}
+
+const cipherstashV3OperatorsByMethod = cipherstashV3QueryOperations()
+
+export function getOperator(method: string): SqlOperationDescriptor {
+  const op = cipherstashV3OperatorsByMethod[method]
+  if (!op) {
+    throw new Error(
+      `cipherstash v3 operator descriptor for method "${method}" not found`,
+    )
+  }
+  return op
+}
+
+/**
+ * Invoke an operator's `impl` and return the produced AST node. Same
+ * cast rationale as the v2 helper: `op.impl` is typed
+ * `(...args: never[]) => QueryOperationReturn` to block accidental
+ * direct invocation; the practical shape is
+ * `(self, ...args) => Expression<...>`.
+ */
+export function callOperator(
+  op: SqlOperationDescriptor,
+  ...args: unknown[]
+): AnyExpression {
+  const impl = op.impl as unknown as (...args: unknown[]) => {
+    buildAst(): AnyExpression
+  }
+  return impl(...args).buildAst()
+}
+
+/**
+ * Build the same `Expression`-like shape the ORM model accessor
+ * synthesises for a column field: `buildAst()` returning the underlying
+ * `ColumnRef` plus the column's return-type metadata carrying the v3
+ * codec id.
+ */
+export function columnAccessorV3(
+  table: string,
+  column: string,
+  codecId: string,
+) {
+  const ref = ColumnRef.of(table, column)
+  return {
+    returnType: { codecId, nullable: true },
+    buildAst: () => ref,
+  }
+}
+
+export function selectWithWhere(whereExpr: AnyExpression) {
+  return SelectAst.from(TableSource.named(TABLE))
+    .withProjection([ProjectionItem.of('id', ColumnRef.of(TABLE, 'id'))])
+    .withWhere(whereExpr)
+}
+
+export function selectWithOrderBy(items: ReadonlyArray<OrderByItem>) {
+  return SelectAst.from(TableSource.named(TABLE))
+    .withProjection([ProjectionItem.of('id', ColumnRef.of(TABLE, 'id'))])
+    .withOrderBy(items)
+}
+
+/**
+ * Unwrap the value carried by a lowered `literal` param (structured
+ * `LoweredParam` entries since 0.9 — same helper as the v2 file).
+ */
+export function literalParamValue(param: LoweredParam): unknown {
+  if (param.kind !== 'literal') {
+    throw new Error(
+      `expected a literal lowered param, got kind '${param.kind}'`,
+    )
+  }
+  return param.value
+}

From c46f2aef17d1ddcc26893280d50cd91fe32228e2 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 14:04:14 -0600
Subject: [PATCH 07/21] feat(prisma-next): v3 schema derivation, SDK adapter,
 runtime descriptor + cipherstashFromStackV3
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- deriveStackSchemasV3(contractJson): walks the 0.14 namespace envelope
  and maps each v3 column's public.eql_v3_* nativeType to its concrete
  @cipherstash/stack/eql/v3 factory (capabilities are intrinsic to the
  domain — no typeParams flags), preserving exact domain identity.
- createCipherstashV3Sdk(client, schemas): adapts the EncryptionV3
  TypedEncryptionClient (structural surface, no casts) to the framework
  CipherstashSdk. Consumes the Task-6 query-term seam: envelopes marked
  by markV3QueryTerm route through encryptQuery — one batch crossing
  per scalar flavour (stack-drizzle's inArray surface), single-call for
  searchableJson (stack-drizzle's JSON containment path) — while
  unmarked values take the storage bulkEncrypt path, position-stable.
- bulkEncryptMiddlewareV3 now collects pg/text@1-bound marked envelopes
  (WHERE operands), forwards the envelope itself through the SDK seam,
  and writes the returned term back as query-term JSONB text without
  stamping it into the envelope's storage-ciphertext slot.
- createCipherstashV3RuntimeDescriptor({ sdk }): the v3 extension
  descriptor under v3's own id/version (decision 1b — never
  co-registered with v2; shared method names collide by design).
- assertV3SchemasAgree: override validation on EXACT domain identity
  (integer_ord ≠ integer_ord_ore despite shared cast_as).
- cipherstashFromStackV3: the v3-only entry point — hard-errors on v2
  cipherstash codec ids and on contracts with no v3 columns; returns
  { extensions, middleware, encryptionClient } like the v2 factory.
- Query-term seam (markV3QueryTerm / v3QueryTermTypeOf +
  EncryptionOperatorError) extracted to src/v3/query-term.ts so the
  middleware/adapter don't import the operator registry; operators-v3
  re-exports it unchanged.
- Exports: v3 surface added to ./runtime and ./stack; new ./v3 subpath
  (ESM, matching the package's existing ESM-only exports map).
- bundling-isolation: allow the v3 catalog chunk (pure domain metadata)
  as a second cross-plane shared chunk alongside the v2 constants chunk.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/package.json             |   4 +
 packages/prisma-next/src/exports/runtime.ts   |  41 ++
 packages/prisma-next/src/exports/stack.ts     |  22 +-
 packages/prisma-next/src/exports/v3.ts        |  78 ++++
 .../prisma-next/src/stack/from-stack-v3.ts    | 161 +++++++
 packages/prisma-next/src/stack/from-stack.ts  |   5 +
 .../prisma-next/src/v3/bulk-encrypt-v3.ts     |  56 ++-
 .../prisma-next/src/v3/derive-schemas-v3.ts   | 150 +++++++
 .../src/v3/from-stack-v3-validate.ts          |  50 +++
 packages/prisma-next/src/v3/operators-v3.ts   |  99 +----
 packages/prisma-next/src/v3/query-term.ts     | 105 +++++
 packages/prisma-next/src/v3/runtime-v3.ts     |  70 +++
 packages/prisma-next/src/v3/sdk-adapter-v3.ts | 326 ++++++++++++++
 .../test/bundling-isolation.test.ts           |  44 +-
 .../test/v3/bulk-encrypt-v3.test.ts           | 194 +++++++++
 .../test/v3/derive-schemas-v3.test.ts         | 178 ++++++++
 .../test/v3/from-stack-divergence-v3.test.ts  |  63 +++
 .../prisma-next/test/v3/from-stack-v3.test.ts |  72 ++++
 .../prisma-next/test/v3/runtime-v3.test.ts    | 101 +++++
 .../test/v3/sdk-adapter-v3.test.ts            | 405 ++++++++++++++++++
 packages/prisma-next/tsup.config.ts           |   1 +
 21 files changed, 2123 insertions(+), 102 deletions(-)
 create mode 100644 packages/prisma-next/src/exports/v3.ts
 create mode 100644 packages/prisma-next/src/stack/from-stack-v3.ts
 create mode 100644 packages/prisma-next/src/v3/derive-schemas-v3.ts
 create mode 100644 packages/prisma-next/src/v3/from-stack-v3-validate.ts
 create mode 100644 packages/prisma-next/src/v3/query-term.ts
 create mode 100644 packages/prisma-next/src/v3/runtime-v3.ts
 create mode 100644 packages/prisma-next/src/v3/sdk-adapter-v3.ts
 create mode 100644 packages/prisma-next/test/v3/derive-schemas-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/from-stack-divergence-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/from-stack-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/runtime-v3.test.ts
 create mode 100644 packages/prisma-next/test/v3/sdk-adapter-v3.test.ts

diff --git a/packages/prisma-next/package.json b/packages/prisma-next/package.json
index a14470ae..01170fc8 100644
--- a/packages/prisma-next/package.json
+++ b/packages/prisma-next/package.json
@@ -60,6 +60,10 @@
 			"types": "./dist/stack.d.ts",
 			"import": "./dist/stack.js"
 		},
+		"./v3": {
+			"types": "./dist/v3.d.ts",
+			"import": "./dist/v3.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"types": "./dist/control.d.ts",
diff --git a/packages/prisma-next/src/exports/runtime.ts b/packages/prisma-next/src/exports/runtime.ts
index 5c3e1498..18d957d6 100644
--- a/packages/prisma-next/src/exports/runtime.ts
+++ b/packages/prisma-next/src/exports/runtime.ts
@@ -120,6 +120,47 @@ export {
   CIPHERSTASH_DOUBLE_CODEC_ID,
   CIPHERSTASH_JSON_CODEC_ID,
 } from '../extension-metadata/constants'
+// ---------------------------------------------------------------------------
+// EQL v3 runtime surface (decision 1b: a SEPARATE extension descriptor
+// under v3's own id — never co-register it with the v2 descriptor
+// above; the shared `cipherstash*` method names collide in the flat
+// OperationRegistry).
+// ---------------------------------------------------------------------------
+export {
+  CIPHERSTASH_V3_CODEC_IDS,
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_SPACE_ID,
+  type CipherstashV3CodecId,
+  isCipherstashV3CodecId,
+} from '../extension-metadata/constants-v3'
+export { bulkEncryptMiddlewareV3 } from '../v3/bulk-encrypt-v3'
+export {
+  CipherstashV3CellCodec,
+  type CipherstashV3CodecParams,
+  cipherstashV3ParamsSchema,
+  createV3CodecDescriptors,
+} from '../v3/codec-runtime-v3'
+export type {
+  EncryptedNumberFromInternalArgs,
+  EncryptedNumberHandle,
+} from '../v3/envelope-number'
+export { EncryptedNumber } from '../v3/envelope-number'
+export {
+  cipherstashV3Asc,
+  cipherstashV3Desc,
+  cipherstashV3QueryOperations,
+} from '../v3/operators-v3'
+export {
+  EncryptionOperatorError,
+  markV3QueryTerm,
+  type V3QueryTermType,
+  v3QueryTermTypeOf,
+} from '../v3/query-term'
+export {
+  type CreateCipherstashV3RuntimeDescriptorOptions,
+  createCipherstashV3RuntimeDescriptor,
+} from '../v3/runtime-v3'
+export { v3FromDriver, v3ToDriver } from '../v3/wire-v3'
 
 export { CIPHERSTASH_EXTENSION_VERSION }
 
diff --git a/packages/prisma-next/src/exports/stack.ts b/packages/prisma-next/src/exports/stack.ts
index 78e5692a..d60fcbba 100644
--- a/packages/prisma-next/src/exports/stack.ts
+++ b/packages/prisma-next/src/exports/stack.ts
@@ -32,5 +32,25 @@ export type {
   CipherstashFromStackResult,
 } from '../stack/from-stack'
 export { cipherstashFromStack } from '../stack/from-stack'
-
+// ---------------------------------------------------------------------------
+// EQL v3 (decision 1b: a SEPARATE entry point — a client is v2 or v3,
+// never both; `cipherstashFromStackV3` rejects contracts carrying v2
+// cipherstash codec ids).
+// ---------------------------------------------------------------------------
+export type {
+  CipherstashFromStackV3Options,
+  CipherstashFromStackV3Result,
+} from '../stack/from-stack-v3'
+export { cipherstashFromStackV3 } from '../stack/from-stack-v3'
 export { createCipherstashSdk } from '../stack/sdk-adapter'
+export type {
+  V3ContractColumnEntry,
+  V3ContractShape,
+} from '../v3/derive-schemas-v3'
+export {
+  deriveStackSchemasV3,
+  v3ContractColumnEntries,
+} from '../v3/derive-schemas-v3'
+export { assertV3SchemasAgree } from '../v3/from-stack-v3-validate'
+export type { CipherstashV3Client } from '../v3/sdk-adapter-v3'
+export { createCipherstashV3Sdk } from '../v3/sdk-adapter-v3'
diff --git a/packages/prisma-next/src/exports/v3.ts b/packages/prisma-next/src/exports/v3.ts
new file mode 100644
index 00000000..779522fc
--- /dev/null
+++ b/packages/prisma-next/src/exports/v3.ts
@@ -0,0 +1,78 @@
+/**
+ * `@cipherstash/prisma-next/v3` — the complete EQL v3 surface in one
+ * import (decision 1b: v3 is a SEPARATE entry point from the v2
+ * `./runtime` / `./stack` composition — a client is v2 or v3, never
+ * both; the two runtime descriptors collide if co-registered).
+ *
+ * Most consumers want exactly one symbol from here:
+ *
+ *   const cipherstash = await cipherstashFromStackV3({ contractJson })
+ *
+ * The remaining exports are the primitives that factory composes —
+ * schema derivation, the SDK adapter, the runtime descriptor, the
+ * bulk-encrypt middleware, envelopes, and the query-term seam — for
+ * advanced users interposing custom logic (multi-tenant SDK routing,
+ * a non-stack `CipherstashSdk` implementation, …).
+ *
+ * Bundle note: this entry re-exports `cipherstashFromStackV3`, which
+ * imports `@cipherstash/stack`. Consumers who need an SDK-free runtime
+ * plane (custom `CipherstashSdk`) should import from `./runtime`
+ * instead — its v3 exports carry no `@cipherstash/stack` client
+ * import-edge.
+ */
+
+// v3's extension identity + the pinned codec-id union.
+export {
+  CIPHERSTASH_V3_CODEC_IDS,
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_SPACE_ID,
+  type CipherstashV3CodecId,
+  isCipherstashV3CodecId,
+} from '../extension-metadata/constants-v3'
+// The v3-only entry point + composition primitives.
+export type {
+  CipherstashFromStackV3Options,
+  CipherstashFromStackV3Result,
+} from '../stack/from-stack-v3'
+export { cipherstashFromStackV3 } from '../stack/from-stack-v3'
+// User-facing value envelopes (version-neutral classes + the v3-only
+// EncryptedNumber).
+export * from '../v3/barrel'
+export { bulkEncryptMiddlewareV3 } from '../v3/bulk-encrypt-v3'
+export {
+  CipherstashV3CellCodec,
+  type CipherstashV3CodecParams,
+  cipherstashV3ParamsSchema,
+  createV3CodecDescriptors,
+} from '../v3/codec-runtime-v3'
+export type {
+  V3ContractColumnEntry,
+  V3ContractShape,
+} from '../v3/derive-schemas-v3'
+export {
+  deriveStackSchemasV3,
+  v3ContractColumnEntries,
+} from '../v3/derive-schemas-v3'
+export { assertV3SchemasAgree } from '../v3/from-stack-v3-validate'
+// Query operators (registered by the runtime descriptor) + the
+// free-standing ORDER BY helpers.
+export {
+  cipherstashV3Asc,
+  cipherstashV3Desc,
+  cipherstashV3QueryOperations,
+} from '../v3/operators-v3'
+// The query-term seam (consumed by custom CipherstashSdk implementations).
+export {
+  EncryptionOperatorError,
+  markV3QueryTerm,
+  type V3QueryTermType,
+  v3QueryTermTypeOf,
+} from '../v3/query-term'
+export {
+  type CreateCipherstashV3RuntimeDescriptorOptions,
+  createCipherstashV3RuntimeDescriptor,
+} from '../v3/runtime-v3'
+export type { CipherstashV3Client } from '../v3/sdk-adapter-v3'
+export { createCipherstashV3Sdk } from '../v3/sdk-adapter-v3'
+// v3 wire helpers (plain JSONB).
+export { v3FromDriver, v3ToDriver } from '../v3/wire-v3'
diff --git a/packages/prisma-next/src/stack/from-stack-v3.ts b/packages/prisma-next/src/stack/from-stack-v3.ts
new file mode 100644
index 00000000..48e95864
--- /dev/null
+++ b/packages/prisma-next/src/stack/from-stack-v3.ts
@@ -0,0 +1,161 @@
+/**
+ * One-call setup for `@cipherstash/prisma-next` against the
+ * `@cipherstash/stack` EQL v3 client — the v3-only sibling of
+ * `./from-stack.ts` (decision 1b: v2 and v3 are SEPARATE entry points
+ * that are never co-registered in one client; the v2
+ * `cipherstashFromStack` is untouched by this module).
+ *
+ *   const cipherstash = await cipherstashFromStackV3({ contractJson })
+ *
+ *   const db = postgres<Contract>({
+ *     contractJson,
+ *     extensions: cipherstash.extensions,
+ *     middleware:  cipherstash.middleware,
+ *   })
+ *
+ * A v3 client is v3-only: a contract carrying a v2 cipherstash codec id
+ * is the WRONG entry point (mixed v2+v3 columns in one client are
+ * unsupported this release) and is a hard error rather than a silently
+ * ignored column.
+ *
+ * Override semantics: a user-supplied `schemasV3` array is allowed to
+ * add tables the contract doesn't model. For tables the contract
+ * **does** declare, the override must agree on EXACT domain identity
+ * per column (`integer_ord` ≠ `integer_ord_ore` even though both are
+ * `cast_as: number`) — divergence throws at setup so ZeroKMS can't end
+ * up minting query terms the installed domain's CHECK rejects.
+ */
+
+import type { AnyV3Table } from '@cipherstash/stack/eql/v3'
+import type { ClientConfig } from '@cipherstash/stack/types'
+import { EncryptionV3, type TypedEncryptionClient } from '@cipherstash/stack/v3'
+import type {
+  SqlMiddleware,
+  SqlRuntimeExtensionDescriptor,
+} from '@prisma-next/sql-runtime'
+
+import { isCipherstashV3CodecId } from '../extension-metadata/constants-v3'
+import { bulkEncryptMiddlewareV3 } from '../v3/bulk-encrypt-v3'
+import {
+  deriveStackSchemasV3,
+  type V3ContractShape,
+  v3ContractColumnEntries,
+} from '../v3/derive-schemas-v3'
+import { assertV3SchemasAgree } from '../v3/from-stack-v3-validate'
+import { createCipherstashV3RuntimeDescriptor } from '../v3/runtime-v3'
+import { createCipherstashV3Sdk } from '../v3/sdk-adapter-v3'
+
+export interface CipherstashFromStackV3Options {
+  /** The contract.json artefact emitted by `prisma-next contract emit`. */
+  readonly contractJson: V3ContractShape
+
+  /**
+   * Optional schema override. Use this to add tables the contract does
+   * not model. For tables the contract **does** declare, the override
+   * must match on column names and EXACT `public.eql_v3_*` domain
+   * identity — divergence throws at setup.
+   */
+  readonly schemasV3?: ReadonlyArray<AnyV3Table>
+
+  /** Pass-through to `EncryptionV3({ config })` (keyset overrides, logging, …). */
+  readonly encryptionConfig?: ClientConfig
+}
+
+export interface CipherstashFromStackV3Result {
+  /** Ready to spread into `postgres<Contract>({ extensions })`. */
+  readonly extensions: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>
+  /** Ready to spread into `postgres<Contract>({ middleware })`. */
+  readonly middleware: ReadonlyArray<SqlMiddleware>
+  /**
+   * The initialised v3 `TypedEncryptionClient` for direct SDK access
+   * outside the ORM path (`encryptModel`, `encryptQuery`, …).
+   */
+  readonly encryptionClient: TypedEncryptionClient<readonly AnyV3Table[]>
+}
+
+export async function cipherstashFromStackV3(
+  opts: CipherstashFromStackV3Options,
+): Promise<CipherstashFromStackV3Result> {
+  const foreignIds = collectNonV3CipherstashCodecIds(opts.contractJson)
+  if (foreignIds.length > 0) {
+    throw new Error(
+      `cipherstashFromStackV3: contract.json contains non-v3 cipherstash codec ids [${foreignIds.join(', ')}]. ` +
+        'A v3 client is v3-only; use cipherstashFromStack for a v2 contract. ' +
+        'Mixed v2+v3 cipherstash columns in one client are unsupported.',
+    )
+  }
+
+  const derived = deriveStackSchemasV3(opts.contractJson)
+  if (derived.length === 0) {
+    throw new Error(
+      'cipherstashFromStackV3: no v3 cipherstash columns found in contract.json. ' +
+        'Declare at least one v3 `cipherstash.Encrypted*()` column in prisma/schema.prisma and re-emit the contract ' +
+        '(or use cipherstashFromStack if this is a v2 contract).',
+    )
+  }
+
+  const schemas = resolveV3Schemas(derived, opts.schemasV3)
+
+  const encryptionClient = await EncryptionV3({
+    schemas,
+    ...(opts.encryptionConfig !== undefined
+      ? { config: opts.encryptionConfig }
+      : {}),
+  })
+
+  const sdk = createCipherstashV3Sdk(encryptionClient, schemas)
+
+  return {
+    extensions: [createCipherstashV3RuntimeDescriptor({ sdk })],
+    middleware: [bulkEncryptMiddlewareV3(sdk)],
+    encryptionClient,
+  }
+}
+
+/**
+ * Every `cipherstash/*` codec id in the contract that is NOT a member
+ * of the pinned v3 set — i.e. v2 (or unknown-generation) cipherstash
+ * columns, which make the contract the wrong input for the v3 entry
+ * point.
+ */
+function collectNonV3CipherstashCodecIds(
+  contractJson: V3ContractShape,
+): string[] {
+  const ids = new Set<string>()
+  for (const { codecId } of v3ContractColumnEntries(contractJson)) {
+    if (
+      typeof codecId === 'string' &&
+      codecId.startsWith('cipherstash/') &&
+      !isCipherstashV3CodecId(codecId)
+    ) {
+      ids.add(codecId)
+    }
+  }
+  return [...ids].sort()
+}
+
+/**
+ * Validate contract-declared tables against their overrides (exact
+ * domain identity) and append override-only tables — same merge
+ * semantics as the v2 `resolveSchemas`.
+ */
+function resolveV3Schemas(
+  derived: ReadonlyArray<AnyV3Table>,
+  override: ReadonlyArray<AnyV3Table> | undefined,
+): ReadonlyArray<AnyV3Table> {
+  if (override === undefined || override.length === 0) return derived
+
+  const derivedByName = new Map(derived.map((t) => [t.tableName, t]))
+  const overrideByName = new Map(override.map((t) => [t.tableName, t]))
+
+  for (const [tableName, derivedTable] of derivedByName) {
+    const overrideTable = overrideByName.get(tableName)
+    if (overrideTable === undefined) continue
+    assertV3SchemasAgree(derivedTable, overrideTable)
+  }
+
+  return [
+    ...derived,
+    ...override.filter((t) => !derivedByName.has(t.tableName)),
+  ]
+}
diff --git a/packages/prisma-next/src/stack/from-stack.ts b/packages/prisma-next/src/stack/from-stack.ts
index 791221dc..10ec6c3f 100644
--- a/packages/prisma-next/src/stack/from-stack.ts
+++ b/packages/prisma-next/src/stack/from-stack.ts
@@ -22,6 +22,11 @@
  * `cast_as`, and the installed index set — divergence throws at
  * setup so ZeroKMS can't end up with an index set that the EQL
  * bundle's installed configuration disagrees with.
+ *
+ * This is the **EQL v2** entry point. For an EQL v3 contract
+ * (`cipherstash/eql-v3/*` codec ids) use `cipherstashFromStackV3`
+ * (`./from-stack-v3.ts`) — v2 and v3 are separate entry points that
+ * are never co-registered in one client (decision 1b).
  */
 
 import { Encryption } from '@cipherstash/stack'
diff --git a/packages/prisma-next/src/v3/bulk-encrypt-v3.ts b/packages/prisma-next/src/v3/bulk-encrypt-v3.ts
index 9b96948a..79caba2c 100644
--- a/packages/prisma-next/src/v3/bulk-encrypt-v3.ts
+++ b/packages/prisma-next/src/v3/bulk-encrypt-v3.ts
@@ -11,6 +11,19 @@
  *     the EQL payload ({@link v3ToDriver} — v3 columns are PG domains
  *     over `jsonb`), never the v2 `eql_v2_encrypted` composite literal.
  *     This module MUST NOT import `encodeEqlV2EncryptedWire`.
+ *   - **Query terms**: v3 additionally collects QUERY-TERM params —
+ *     envelopes marked by the v3 operators (`markV3QueryTerm`) and
+ *     bound under the bare-rendering `pg/text@1` codec, so they carry
+ *     no v3 codec id. The ENVELOPE itself is forwarded through
+ *     `sdk.bulkEncrypt` as the value, so the mark survives the SDK
+ *     boundary; the v3 SDK adapter (`./sdk-adapter-v3`) reads the mark
+ *     and routes the operand through the client's `encryptQuery`
+ *     (a ciphertext-free term), never the storage encrypt. The
+ *     resulting term is written back as JSONB text — exactly what the
+ *     operator's `$N::eql_v3.query_<domain>` template expects — but is
+ *     NOT stamped into the envelope's ciphertext slot (a query term is
+ *     not the cell's storage ciphertext; stamping it would poison
+ *     later write-path reuse of the same envelope).
  *
  * The `(table, column)` routing-key stamping is NOT forked: the AST walk
  * is version-neutral (it touches only the shared envelope base) and is
@@ -44,6 +57,7 @@ import type { CipherstashSdk } from '../execution/sdk'
 import { CIPHERSTASH_V3_CODEC_ID_SET } from '../extension-metadata/constants-v3'
 // Version-neutral AST routing-key stamping — reused, not the v2 encode path.
 import { stampRoutingKeysFromAst } from '../middleware/bulk-encrypt'
+import { v3QueryTermTypeOf } from './query-term'
 import { v3ToDriver } from './wire-v3'
 
 /**
@@ -98,14 +112,19 @@ export function bulkEncryptMiddlewareV3(sdk: CipherstashSdk): SqlMiddleware {
 
         // Replace each ParamRef's value with the plain JSONB text the
         // pg driver can serialise directly (the envelope instance
-        // itself would fail at the driver boundary). The envelope's
-        // ciphertext slot is also stamped via `setHandleCiphertext`
-        // and its plaintext slot retained, so follow-on reuse of the
-        // same envelope skips the re-encrypt round-trip.
+        // itself would fail at the driver boundary). For STORAGE
+        // targets the envelope's ciphertext slot is also stamped via
+        // `setHandleCiphertext` and its plaintext slot retained, so
+        // follow-on reuse of the same envelope skips the re-encrypt
+        // round-trip. QUERY-TERM targets skip the stamp: the returned
+        // value is a ciphertext-free query term, not the cell's
+        // storage ciphertext.
         params.replaceValues(
           group.map((t, i) => {
             const ciphertext = ciphertexts[i]
-            setHandleCiphertext(t.envelope, ciphertext)
+            if (v3QueryTermTypeOf(t.envelope) === undefined) {
+              setHandleCiphertext(t.envelope, ciphertext)
+            }
             return {
               ref: t.ref,
               newValue: v3ToDriver(ciphertext),
@@ -122,6 +141,33 @@ function collectV3Targets(
 ): BulkEncryptTarget<ParamRefHandle<string | undefined>>[] {
   const targets: BulkEncryptTarget<ParamRefHandle<string | undefined>>[] = []
   for (const entry of params.entries()) {
+    const entryValue = entry.value
+    if (
+      entryValue instanceof EncryptedEnvelopeBase &&
+      v3QueryTermTypeOf(entryValue) !== undefined
+    ) {
+      // v3 QUERY TERM — marked by a v3 operator at lowering time and
+      // bound under `pg/text@1` (no v3 codec id, so the storage arm
+      // below never sees it). The envelope itself travels through the
+      // SDK seam as the "plaintext" value so the v3 SDK adapter can
+      // read the mark and mint an `encryptQuery` term.
+      const handle = entryValue.expose()
+      if (handle.table === undefined || handle.column === undefined) {
+        throw new Error(
+          'cipherstash v3 bulk-encrypt: query-term envelope reached the bulk-encrypt phase without a ' +
+            '(table, column) routing context. Operators stamp routing from the column-bound self ' +
+            'expression; envelopes embedded in raw SQL must stamp routing context explicitly via ' +
+            '`setHandleRoutingKey` before execute.',
+        )
+      }
+      targets.push({
+        ref: entry.ref,
+        plaintext: entryValue,
+        envelope: entryValue,
+        routingKey: { table: handle.table, column: handle.column },
+      })
+      continue
+    }
     if (
       entry.codecId === undefined ||
       !CIPHERSTASH_V3_CODEC_ID_SET.has(entry.codecId)
diff --git a/packages/prisma-next/src/v3/derive-schemas-v3.ts b/packages/prisma-next/src/v3/derive-schemas-v3.ts
new file mode 100644
index 00000000..4b93ed7f
--- /dev/null
+++ b/packages/prisma-next/src/v3/derive-schemas-v3.ts
@@ -0,0 +1,150 @@
+/**
+ * Derive `@cipherstash/stack/eql/v3` schemas from a Prisma Next
+ * contract — the v3 twin of `../stack/derive-schemas.ts`.
+ *
+ * `contract.json` already declares every encrypted column the framework
+ * knows about: its physical table name (after `@map(...)` collapsing),
+ * its physical column name, its v3 codec id
+ * (`cipherstash/eql-v3/eql_v3_*@1`), and its concrete `public.eql_v3_*`
+ * domain as `nativeType`. `deriveStackSchemasV3` walks the
+ * `storage.namespaces.<ns>.entries.table` envelope and returns one v3
+ * `EncryptedTable` per table with at least one v3-codec'd column, ready
+ * to pass to `EncryptionV3({ schemas })`.
+ *
+ * The v3-specific delta vs the v2 derivation: the concrete column
+ * factory is selected by `nativeType` via the catalog's
+ * `V3_FACTORY_BY_NATIVE_TYPE` (the `(codec id) ⟺ (public.* domain)`
+ * bijection), never by `typeParams` flags — a v3 domain's capabilities
+ * are intrinsic to the domain, not per-column authoring options. The
+ * derived column keeps its concrete class (`EncryptedTextSearchColumn`,
+ * `EncryptedIntegerOrdColumn`, …), so exact domain identity survives
+ * into override validation (`assertV3SchemasAgree`).
+ */
+
+import {
+  type AnyEncryptedV3Column,
+  type AnyV3Table,
+  encryptedTable,
+} from '@cipherstash/stack/eql/v3'
+
+import { isCipherstashV3CodecId } from '../extension-metadata/constants-v3'
+import { V3_FACTORY_BY_NATIVE_TYPE } from './catalog'
+
+interface V3ColumnView {
+  readonly codecId?: string | null
+  readonly nativeType?: string
+  readonly typeParams?: unknown
+}
+
+interface V3TableView {
+  readonly columns?: Readonly<Record<string, V3ColumnView>>
+}
+
+/**
+ * Structural shape of the subset of `contract.json` this derivation
+ * reads — the 0.14 `storage.namespaces.<ns>.entries.table` envelope,
+ * mirroring the v2 `ContractStorageView`. Declared structurally (vs
+ * importing the framework type) so the derivation has no
+ * `@prisma-next/*` import-edge and is callable against a raw
+ * JSON-typed import.
+ */
+export interface V3ContractShape {
+  readonly storage?: {
+    readonly namespaces?: Readonly<
+      Record<
+        string,
+        {
+          readonly entries?: {
+            readonly table?: Readonly<Record<string, V3TableView>>
+          }
+        }
+      >
+    >
+  }
+}
+
+function contractTables(
+  contractJson: V3ContractShape,
+): Record<string, V3TableView> {
+  const namespaces = contractJson.storage?.namespaces
+  if (!namespaces) return {}
+  const tables: Record<string, V3TableView> = {}
+  for (const namespace of Object.values(namespaces)) {
+    Object.assign(tables, namespace.entries?.table)
+  }
+  return tables
+}
+
+/** One contract column, flattened out of the namespace envelope. */
+export interface V3ContractColumnEntry {
+  readonly tableName: string
+  readonly columnName: string
+  readonly codecId: string | undefined
+  readonly nativeType: string | undefined
+}
+
+/**
+ * Flatten every contract column across all namespaces/tables. Shared by
+ * {@link deriveStackSchemasV3} and `cipherstashFromStackV3`'s
+ * v2-codec-id scan (a v3 client is v3-only; foreign cipherstash codec
+ * ids are a hard error there).
+ */
+export function v3ContractColumnEntries(
+  contractJson: V3ContractShape,
+): V3ContractColumnEntry[] {
+  const entries: V3ContractColumnEntry[] = []
+  for (const [tableName, table] of Object.entries(
+    contractTables(contractJson),
+  )) {
+    for (const [columnName, column] of Object.entries(table.columns ?? {})) {
+      entries.push({
+        tableName,
+        columnName,
+        codecId: column.codecId ?? undefined,
+        nativeType: column.nativeType,
+      })
+    }
+  }
+  return entries
+}
+
+/**
+ * Derive an array of v3 `EncryptedTable` builders from a Prisma Next
+ * contract. Returns an empty array when no v3 cipherstash columns are
+ * present; callers must still pass at least one table to
+ * `EncryptionV3({ schemas })`, which requires a non-empty array.
+ */
+export function deriveStackSchemasV3(
+  contractJson: V3ContractShape,
+): ReadonlyArray<AnyV3Table> {
+  const result: AnyV3Table[] = []
+
+  for (const [tableName, table] of Object.entries(
+    contractTables(contractJson),
+  )) {
+    const columns: Record<string, AnyEncryptedV3Column> = {}
+    for (const [columnName, column] of Object.entries(table.columns ?? {})) {
+      const codecId = column.codecId
+      if (codecId == null || !isCipherstashV3CodecId(codecId)) continue
+
+      const nativeType = column.nativeType
+      const factory =
+        nativeType !== undefined
+          ? V3_FACTORY_BY_NATIVE_TYPE.get(nativeType)
+          : undefined
+      if (!factory) {
+        throw new Error(
+          `deriveStackSchemasV3: column "${tableName}"."${columnName}" has v3 codec id "${codecId}" ` +
+            `but nativeType "${nativeType}" maps to no eql/v3 factory. ` +
+            'Re-emit the contract with a current @cipherstash/prisma-next.',
+        )
+      }
+      columns[columnName] = factory(columnName)
+    }
+
+    if (Object.keys(columns).length === 0) continue
+    result.push(encryptedTable(tableName, columns))
+  }
+
+  return result
+}
diff --git a/packages/prisma-next/src/v3/from-stack-v3-validate.ts b/packages/prisma-next/src/v3/from-stack-v3-validate.ts
new file mode 100644
index 00000000..7816a06e
--- /dev/null
+++ b/packages/prisma-next/src/v3/from-stack-v3-validate.ts
@@ -0,0 +1,50 @@
+/**
+ * v3 override validation for `cipherstashFromStackV3`.
+ *
+ * Compares EXACT domain identity (`getEqlType()` → `public.eql_v3_*`),
+ * not the v2 rule of cast_as + installed-index-set equivalence:
+ * `integer_ord` and `integer_ord_ore` share `cast_as: number` and an
+ * ordering index family, but are different domains whose on-disk CHECK
+ * constraints and query operand types (`eql_v3.query_integer_ord` vs
+ * `eql_v3.query_integer_ord_ore`) diverge — an override that swaps one
+ * for the other would produce query terms the installed domain rejects.
+ */
+
+import type { AnyV3Table } from '@cipherstash/stack/eql/v3'
+
+/**
+ * Assert that a user-supplied v3 table override agrees with the
+ * contract-derived table on every column: same column set (keyed by the
+ * physical DB column name) and, per column, the same concrete
+ * `public.eql_v3_*` domain. Throws with a fix-the-schema hint on the
+ * first divergence.
+ */
+export function assertV3SchemasAgree(
+  derived: AnyV3Table,
+  override: AnyV3Table,
+): void {
+  const derivedDomains = domainsByColumn(derived)
+  const overrideDomains = domainsByColumn(override)
+
+  const columns = new Set([...derivedDomains.keys(), ...overrideDomains.keys()])
+  for (const column of [...columns].sort()) {
+    const derivedDomain = derivedDomains.get(column)
+    const overrideDomain = overrideDomains.get(column)
+    if (derivedDomain !== overrideDomain) {
+      throw new Error(
+        `cipherstashFromStackV3: schema divergence on column "${derived.tableName}"."${column}". ` +
+          `Contract domain "${derivedDomain ?? '(missing)'}" but override domain "${overrideDomain ?? '(missing)'}". ` +
+          'Overrides must match the contract exactly on contract-declared tables — ' +
+          'fix prisma/schema.prisma and re-emit rather than overriding.',
+      )
+    }
+  }
+}
+
+function domainsByColumn(table: AnyV3Table): Map<string, string> {
+  const domains = new Map<string, string>()
+  for (const builder of Object.values(table.columnBuilders)) {
+    domains.set(builder.getName(), builder.getEqlType())
+  }
+  return domains
+}
diff --git a/packages/prisma-next/src/v3/operators-v3.ts b/packages/prisma-next/src/v3/operators-v3.ts
index 5dc45815..a7d0f93c 100644
--- a/packages/prisma-next/src/v3/operators-v3.ts
+++ b/packages/prisma-next/src/v3/operators-v3.ts
@@ -66,7 +66,6 @@
  * and the shared trait constants.
  */
 
-import type { QueryTypeName } from '@cipherstash/stack/types'
 import type { CodecTrait } from '@prisma-next/framework-components/codec'
 import type {
   SqlOperationDescriptor,
@@ -87,7 +86,7 @@ import {
   toExpr,
 } from '@prisma-next/sql-relational-core/expression'
 import {
-  EncryptedEnvelopeBase,
+  type EncryptedEnvelopeBase,
   setHandleRoutingKey,
 } from '../execution/envelope-base'
 import { EncryptedBigInt } from '../execution/envelope-bigint'
@@ -103,6 +102,22 @@ import {
 } from '../extension-metadata/constants-v3'
 import { V3_DOMAIN_META_BY_CODEC_ID, type V3DomainMeta } from './catalog'
 import { EncryptedNumber } from './envelope-number'
+import {
+  EncryptionOperatorError,
+  markV3QueryTerm,
+  type V3QueryTermType,
+} from './query-term'
+
+// The query-term seam (mark/read + the shared operator error) lives in
+// `./query-term` so the bulk-encrypt middleware and the v3 SDK adapter
+// can consume it without importing this module's operator registry.
+// Re-exported here so the operator surface keeps its original shape.
+export {
+  EncryptionOperatorError,
+  markV3QueryTerm,
+  type V3QueryTermType,
+  v3QueryTermTypeOf,
+} from './query-term'
 
 /**
  * Codec ID of the framework's Postgres boolean codec — referenced as a
@@ -123,86 +138,6 @@ type PgBoolReturn = {
   readonly nullable: false
 }
 
-/**
- * A dedicated error for v3 operator gating, operand-coercion, and
- * misuse failures, carrying the offending column/table/operator for
- * diagnostics.
- *
- * INTENTIONAL FORK of `@cipherstash/stack-drizzle`'s error of the same
- * name (same shape, same rationale): sharing it would couple two
- * independently-versioned public packages. v3-owned — the v2 operator
- * surface keeps throwing plain `TypeError`s.
- */
-export class EncryptionOperatorError extends Error {
-  constructor(
-    message: string,
-    public readonly context?: {
-      columnName?: string
-      tableName?: string
-      operator?: string
-    },
-  ) {
-    super(message)
-    this.name = 'EncryptionOperatorError'
-  }
-}
-
-/**
- * The query-term flavours a v3 operator can mint — the subset of the
- * stack's `QueryTypeName` union that maps 1:1 onto the four
- * capability families (`steVecSelector`/`steVecTerm` are subsumed by
- * `searchableJson`, which auto-infers).
- */
-export type V3QueryTermType = Extract<
-  QueryTypeName,
-  'equality' | 'orderAndRange' | 'freeTextSearch' | 'searchableJson'
->
-
-/**
- * Query-term marks, keyed by envelope identity. A WeakMap sidecar
- * rather than a handle slot so the version-neutral
- * `EncryptedEnvelopeHandle` (shared with v2, which has no query-term
- * concept) stays untouched.
- */
-const V3_QUERY_TERM_TYPES = new WeakMap<
-  EncryptedEnvelopeBase<unknown>,
-  V3QueryTermType
->()
-
-/**
- * Mark an envelope as a v3 QUERY TERM of the given flavour. Stamped by
- * every operator at lowering time; consumed by the v3 SDK boundary
- * (Task 7), which must encrypt marked envelopes via
- * `encryptQuery({ queryType })` — a ciphertext-free term — instead of
- * the storage `bulkEncrypt` path. Write-once-wins with a conflict
- * check, mirroring `setHandleRoutingKey`: one envelope instance feeds
- * one query flavour.
- */
-export function markV3QueryTerm(
-  envelope: EncryptedEnvelopeBase<unknown>,
-  queryType: V3QueryTermType,
-): void {
-  const existing = V3_QUERY_TERM_TYPES.get(envelope)
-  if (existing !== undefined && existing !== queryType) {
-    throw new EncryptionOperatorError(
-      `cipherstash v3 operator: envelope is already marked as a "${existing}" query term, refusing to remark as "${queryType}". Construct a fresh envelope per operator call.`,
-    )
-  }
-  V3_QUERY_TERM_TYPES.set(envelope, queryType)
-}
-
-/**
- * Read an envelope's query-term mark. `undefined` means the envelope
- * is a storage value (write path), not a query term.
- */
-export function v3QueryTermTypeOf(
-  envelope: unknown,
-): V3QueryTermType | undefined {
-  return envelope instanceof EncryptedEnvelopeBase
-    ? V3_QUERY_TERM_TYPES.get(envelope)
-    : undefined
-}
-
 /** Per-call column context resolved from the `self` expression. */
 interface ColumnContext {
   readonly meta: V3DomainMeta
diff --git a/packages/prisma-next/src/v3/query-term.ts b/packages/prisma-next/src/v3/query-term.ts
new file mode 100644
index 00000000..4becb49a
--- /dev/null
+++ b/packages/prisma-next/src/v3/query-term.ts
@@ -0,0 +1,105 @@
+/**
+ * The v3 QUERY-TERM seam — the tiny contract between three modules:
+ *
+ *   - `./operators-v3` MARKS: every v3 predicate operator wraps its
+ *     operand in a per-castAs envelope and stamps the query flavour it
+ *     needs (`markV3QueryTerm`) before binding the envelope as a
+ *     `pg/text@1` param.
+ *   - `./bulk-encrypt-v3` COLLECTS: the middleware recognises marked
+ *     envelopes among the plan params (they carry no v3 codec id — the
+ *     `pg/text@1` binding keeps them out of the storage jurisdiction)
+ *     and forwards the envelope itself through `CipherstashSdk.bulkEncrypt`
+ *     so the mark survives the SDK boundary.
+ *   - `./sdk-adapter-v3` ROUTES: the SDK adapter reads the mark
+ *     (`v3QueryTermTypeOf`) and encrypts marked envelopes via the stack
+ *     client's `encryptQuery({ queryType })` — a ciphertext-free term —
+ *     instead of the storage `bulkEncrypt` path.
+ *
+ * Extracted from `./operators-v3` so the middleware and SDK adapter can
+ * consume the seam without importing the operator registry (and its
+ * `@prisma-next/sql-operations` / expression machinery). The operator
+ * module re-exports everything here, so its public surface is unchanged.
+ */
+
+import type { QueryTypeName } from '@cipherstash/stack/types'
+import { EncryptedEnvelopeBase } from '../execution/envelope-base'
+
+/**
+ * A dedicated error for v3 operator gating, operand-coercion, and
+ * misuse failures, carrying the offending column/table/operator for
+ * diagnostics.
+ *
+ * INTENTIONAL FORK of `@cipherstash/stack-drizzle`'s error of the same
+ * name (same shape, same rationale): sharing it would couple two
+ * independently-versioned public packages. v3-owned — the v2 operator
+ * surface keeps throwing plain `TypeError`s.
+ */
+export class EncryptionOperatorError extends Error {
+  constructor(
+    message: string,
+    public readonly context?: {
+      columnName?: string
+      tableName?: string
+      operator?: string
+    },
+  ) {
+    super(message)
+    this.name = 'EncryptionOperatorError'
+  }
+}
+
+/**
+ * The query-term flavours a v3 operator can mint — the subset of the
+ * stack's `QueryTypeName` union that maps 1:1 onto the four
+ * capability families (`steVecSelector`/`steVecTerm` are subsumed by
+ * `searchableJson`, which auto-infers).
+ */
+export type V3QueryTermType = Extract<
+  QueryTypeName,
+  'equality' | 'orderAndRange' | 'freeTextSearch' | 'searchableJson'
+>
+
+/**
+ * Query-term marks, keyed by envelope identity. A WeakMap sidecar
+ * rather than a handle slot so the version-neutral
+ * `EncryptedEnvelopeHandle` (shared with v2, which has no query-term
+ * concept) stays untouched.
+ */
+const V3_QUERY_TERM_TYPES = new WeakMap<
+  EncryptedEnvelopeBase<unknown>,
+  V3QueryTermType
+>()
+
+/**
+ * Mark an envelope as a v3 QUERY TERM of the given flavour. Stamped by
+ * every operator at lowering time; consumed by the v3 SDK boundary
+ * (Task 7), which must encrypt marked envelopes via
+ * `encryptQuery({ queryType })` — a ciphertext-free term — instead of
+ * the storage `bulkEncrypt` path. Write-once-wins with a conflict
+ * check, mirroring `setHandleRoutingKey`: one envelope instance feeds
+ * one query flavour.
+ */
+export function markV3QueryTerm(
+  envelope: EncryptedEnvelopeBase<unknown>,
+  queryType: V3QueryTermType,
+): void {
+  const existing = V3_QUERY_TERM_TYPES.get(envelope)
+  if (existing !== undefined && existing !== queryType) {
+    throw new EncryptionOperatorError(
+      `cipherstash v3 operator: envelope is already marked as a "${existing}" query term, refusing to remark as "${queryType}". Construct a fresh envelope per operator call.`,
+    )
+  }
+  V3_QUERY_TERM_TYPES.set(envelope, queryType)
+}
+
+/**
+ * Read an envelope's query-term mark. `undefined` means the envelope
+ * is a storage value (write path), not a query term.
+ */
+export function v3QueryTermTypeOf(
+  envelope: unknown,
+): V3QueryTermType | undefined {
+  return envelope instanceof EncryptedEnvelopeBase
+    ? V3_QUERY_TERM_TYPES.get(envelope)
+    : undefined
+}
diff --git a/packages/prisma-next/src/v3/runtime-v3.ts b/packages/prisma-next/src/v3/runtime-v3.ts
new file mode 100644
index 00000000..a7712ae8
--- /dev/null
+++ b/packages/prisma-next/src/v3/runtime-v3.ts
@@ -0,0 +1,70 @@
+/**
+ * The v3 runtime extension descriptor —
+ * `createCipherstashV3RuntimeDescriptor({ sdk })`, the v3 twin of
+ * `../exports/runtime.ts`'s `createCipherstashRuntimeDescriptor`.
+ *
+ * Composes the SDK-bound v3 codec descriptors (Task 4, one per catalog
+ * domain) and the v3 query operations (Task 6) into a single
+ * `SqlRuntimeExtensionDescriptor<'postgres'>` under v3's OWN extension
+ * id/version (decision 1b) — NOT the v2 `CIPHERSTASH_SPACE_ID` /
+ * `CIPHERSTASH_EXTENSION_VERSION`. The registered method names
+ * (`cipherstashEq`, …) are identical to the v2 set, so the v2 and v3
+ * descriptors must NEVER be co-registered in one client: the flat,
+ * method-name-keyed `OperationRegistry` throws on the shared names
+ * (pinned in `test/v3/operator-gating-v3.test.ts`). A client is v2 or
+ * v3, never both.
+ *
+ * The v3 bulk-encrypt middleware ships separately
+ * (`bulkEncryptMiddlewareV3(sdk)`) because
+ * `SqlRuntimeExtensionDescriptor` does not own a middleware slot —
+ * same split as v2.
+ */
+
+import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime'
+import type { CipherstashSdk } from '../execution/sdk'
+import {
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_SPACE_ID,
+} from '../extension-metadata/constants-v3'
+import { createV3CodecDescriptors } from './codec-runtime-v3'
+import { cipherstashV3QueryOperations } from './operators-v3'
+
+export interface CreateCipherstashV3RuntimeDescriptorOptions {
+  readonly sdk: CipherstashSdk
+}
+
+/**
+ * Compose the SDK-bound v3 codec descriptors + query operations into a
+ * single `SqlRuntimeExtensionDescriptor<'postgres'>`.
+ *
+ * The descriptor is per-SDK: each codec captures the SDK for the
+ * read-side decrypt path. Multi-tenant deployments construct one
+ * descriptor per tenant SDK so per-tenant key material never crosses
+ * runtimes (same contract as v2).
+ */
+export function createCipherstashV3RuntimeDescriptor(
+  opts: CreateCipherstashV3RuntimeDescriptorOptions,
+): SqlRuntimeExtensionDescriptor<'postgres'> {
+  const descriptors = createV3CodecDescriptors(opts.sdk)
+
+  return {
+    kind: 'extension' as const,
+    id: CIPHERSTASH_V3_SPACE_ID,
+    version: CIPHERSTASH_V3_EXTENSION_VERSION,
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    types: {
+      codecTypes: {
+        codecDescriptors: descriptors,
+      },
+    },
+    codecs: () => descriptors,
+    queryOperations: () => cipherstashV3QueryOperations(),
+    create() {
+      return {
+        familyId: 'sql' as const,
+        targetId: 'postgres' as const,
+      }
+    },
+  }
+}
diff --git a/packages/prisma-next/src/v3/sdk-adapter-v3.ts b/packages/prisma-next/src/v3/sdk-adapter-v3.ts
new file mode 100644
index 00000000..37c4c501
--- /dev/null
+++ b/packages/prisma-next/src/v3/sdk-adapter-v3.ts
@@ -0,0 +1,326 @@
+/**
+ * Adapt the `@cipherstash/stack` EQL v3 client (the
+ * `TypedEncryptionClient` returned by `EncryptionV3`) to the
+ * framework-native `CipherstashSdk` shape consumed by
+ * `createCipherstashV3RuntimeDescriptor({ sdk })` and
+ * `bulkEncryptMiddlewareV3(sdk)`.
+ *
+ * The framework calls into the SDK with `(table, column)` routing-key
+ * strings; the adapter resolves those strings back to the typed v3
+ * `EncryptedTable` / column-builder objects via a registry built from
+ * the supplied schemas, keyed on the **physical** column name
+ * (post-`@map`, via `getName()`).
+ *
+ * ## Two encryption paths behind one `bulkEncrypt` seam
+ *
+ * v3 has two kinds of encrypted values, and the `values` array of a
+ * `bulkEncrypt` call can carry both (the middleware groups params by
+ * `(table, column)`, and an `UPDATE … SET col = $1 WHERE col = $2`
+ * puts a storage value and a query term in one group):
+ *
+ *   - **Storage values** (write path): raw plaintexts. Encrypted via
+ *     the client's storage `bulkEncrypt` — one crossing per call.
+ *   - **Query terms**: envelope instances marked by the v3 operators
+ *     (`markV3QueryTerm`, see `./query-term`). Encrypted via the
+ *     client's `encryptQuery` with the marked `queryType`, minting a
+ *     CIPHERTEXT-FREE term the `eql_v3.query_<domain>` cast needs.
+ *     Scalar flavours (`equality` / `orderAndRange` / `freeTextSearch`)
+ *     batch all same-flavour terms into ONE `encryptQuery(terms[])`
+ *     crossing — the same batch surface `@cipherstash/stack-drizzle`'s
+ *     v3 `inArray` uses. `searchableJson` terms go through the single
+ *     `encryptQuery(value, { queryType: 'searchableJson' })` form,
+ *     mirroring stack-drizzle's JSON containment path (the batch
+ *     operation is scalar-only — it never produces a ste_vec term).
+ *
+ * Results are reassembled position-stable, so the middleware's
+ * write-back aligns index-for-index with its collected targets.
+ *
+ * Unlike the v2 adapter there is no plaintext coercion at this
+ * boundary: protect-ffi in v3/eqlVersion-3 mode natively handles
+ * `bigint` (bounds-checked int8) and `Date` plaintexts, so values pass
+ * through unchanged and the client validates against the column's
+ * domain.
+ */
+
+import type {
+  AnyEncryptedV3Column,
+  AnyV3Table,
+} from '@cipherstash/stack/eql/v3'
+import { EncryptedEnvelopeBase } from '../execution/envelope-base'
+import type { CipherstashRoutingKey, CipherstashSdk } from '../execution/sdk'
+import { type V3QueryTermType, v3QueryTermTypeOf } from './query-term'
+
+// Mirrors `@byteslice/result`'s discriminated `Result<S, F>` shape
+// (which `@cipherstash/stack` returns) without forcing the package to
+// depend on `@byteslice/result` directly. Same pattern as the v2
+// adapter.
+type StackResult<T> =
+  | { readonly failure?: never; readonly data: T }
+  | { readonly failure: { readonly message: string } }
+
+/**
+ * Minimal structural view of the stack v3 client this adapter drives —
+ * satisfied by the `TypedEncryptionClient` that `EncryptionV3` returns
+ * (whatever its schema tuple) AND by a hand-rolled test double, neither
+ * needing a cast.
+ *
+ * `encryptQuery`'s `never` operands are deliberate (same rationale as
+ * `@cipherstash/stack-drizzle`'s `OperandEncryptionClient`): the real
+ * client's `encryptQuery` is generic — `queryType` is constrained to
+ * the column's own query types — which a concrete signature here cannot
+ * match. `never` params keep the structural surface satisfiable by that
+ * generic method; the call sites cast their real operands.
+ */
+export interface CipherstashV3Client {
+  bulkEncrypt(
+    payload: ReadonlyArray<{ plaintext: unknown }>,
+    opts: { table: AnyV3Table; column: AnyEncryptedV3Column },
+  ): PromiseLike<StackResult<ReadonlyArray<{ data: unknown }>>>
+  decrypt(encrypted: unknown): PromiseLike<StackResult<unknown>>
+  bulkDecrypt(
+    payloads: ReadonlyArray<{ data: unknown }>,
+  ): PromiseLike<
+    StackResult<
+      ReadonlyArray<{ readonly data?: unknown; readonly error?: unknown }>
+    >
+  >
+  encryptQuery(plaintext: never, opts: never): PromiseLike<StackResult<unknown>>
+  encryptQuery(terms: never): PromiseLike<StackResult<ReadonlyArray<unknown>>>
+}
+
+interface V3RegistryEntry {
+  readonly table: AnyV3Table
+  readonly columns: ReadonlyMap<string, AnyEncryptedV3Column>
+}
+
+/** One value slot awaiting encryption, with its position in `values`. */
+interface PendingSlot {
+  readonly index: number
+  readonly plaintext: unknown
+}
+
+/**
+ * Build a `CipherstashSdk` from a stack v3 client plus the v3 schemas
+ * it was constructed with.
+ *
+ * `schemas` should be the exact `AnyV3Table[]` passed to
+ * `EncryptionV3({ schemas })` (typically the return value of
+ * `deriveStackSchemasV3`). The adapter uses it to translate framework
+ * `(table, column)` routing-key strings back to the typed schema
+ * objects the client's operations expect.
+ */
+export function createCipherstashV3Sdk(
+  client: CipherstashV3Client,
+  schemas: ReadonlyArray<AnyV3Table>,
+): CipherstashSdk {
+  const registry = new Map<string, V3RegistryEntry>()
+  for (const table of schemas) {
+    const columns = new Map<string, AnyEncryptedV3Column>()
+    for (const builder of Object.values(table.columnBuilders)) {
+      columns.set(builder.getName(), builder)
+    }
+    registry.set(table.tableName, { table, columns })
+  }
+
+  function lookup(routingKey: CipherstashRoutingKey): {
+    table: AnyV3Table
+    column: AnyEncryptedV3Column
+  } {
+    const entry = registry.get(routingKey.table)
+    if (entry === undefined) {
+      throw new Error(
+        `cipherstash v3 SDK adapter: routing-key table "${routingKey.table}" is not in the v3 schemas. ` +
+          'If you derived your schemas with `deriveStackSchemasV3(contractJson)`, this means the contract has no ' +
+          'v3 cipherstash columns on that table — check `prisma/schema.prisma` and re-emit the contract.',
+      )
+    }
+    const column = entry.columns.get(routingKey.column)
+    if (column === undefined) {
+      throw new Error(
+        `cipherstash v3 SDK adapter: routing-key column "${routingKey.column}" is not on v3 table "${routingKey.table}". ` +
+          'Routing keys use physical column names (post-`@map`). Check `prisma/schema.prisma` and re-emit the contract.',
+      )
+    }
+    return { table: entry.table, column }
+  }
+
+  return {
+    async bulkEncrypt({ values, routingKey }) {
+      const { table, column } = lookup(routingKey)
+      const results = new Array<unknown>(values.length)
+
+      // Partition the batch: unmarked values take the storage path;
+      // marked envelopes are query terms, grouped by flavour.
+      const storage: PendingSlot[] = []
+      const scalarTerms = new Map<
+        Exclude<V3QueryTermType, 'searchableJson'>,
+        PendingSlot[]
+      >()
+      const jsonTerms: PendingSlot[] = []
+
+      values.forEach((value, index) => {
+        const queryType = v3QueryTermTypeOf(value)
+        if (
+          queryType === undefined ||
+          !(value instanceof EncryptedEnvelopeBase)
+        ) {
+          storage.push({ index, plaintext: value })
+          return
+        }
+        const plaintext = value.expose().plaintext
+        if (plaintext === undefined) {
+          throw new Error(
+            `cipherstash v3 SDK adapter: "${queryType}" query-term envelope for ` +
+              `"${routingKey.table}"."${routingKey.column}" has no plaintext to encrypt. ` +
+              'Operator operands must be plaintext values or envelopes built with `Encrypted*.from(...)`.',
+          )
+        }
+        if (queryType === 'searchableJson') {
+          jsonTerms.push({ index, plaintext })
+        } else {
+          const group = scalarTerms.get(queryType)
+          if (group === undefined) {
+            scalarTerms.set(queryType, [{ index, plaintext }])
+          } else {
+            group.push({ index, plaintext })
+          }
+        }
+      })
+
+      if (storage.length > 0) {
+        const result = await client.bulkEncrypt(
+          storage.map((slot) => ({ plaintext: slot.plaintext })),
+          { table, column },
+        )
+        const data = unwrap(result, 'bulkEncrypt')
+        if (data.length !== storage.length) {
+          throw new Error(
+            `cipherstash v3 bulkEncrypt: client returned ${data.length} ciphertexts for ${storage.length} plaintexts ` +
+              `on "${routingKey.table}"."${routingKey.column}".`,
+          )
+        }
+        storage.forEach((slot, i) => {
+          results[slot.index] = data[i]?.data
+        })
+      }
+
+      for (const [queryType, group] of scalarTerms) {
+        // ONE batch crossing per scalar flavour — the position-stable
+        // `encryptQuery(terms[])` surface stack-drizzle's v3 `inArray`
+        // uses.
+        const terms = group.map((slot) => ({
+          value: slot.plaintext,
+          table,
+          column,
+          queryType,
+        }))
+        // Cast rationale: `CipherstashV3Client.encryptQuery` declares
+        // `never` operands so the real client's GENERIC method satisfies
+        // the structural surface (see the interface doc); the concrete
+        // operand is re-widened at each call site.
+        const result = await client.encryptQuery(terms as never)
+        const data = unwrap(result, `encryptQuery(${queryType})`)
+        if (data.length !== group.length) {
+          throw new Error(
+            `cipherstash v3 encryptQuery(${queryType}): client returned ${data.length} terms for ${group.length} values ` +
+              `on "${routingKey.table}"."${routingKey.column}".`,
+          )
+        }
+        group.forEach((slot, i) => {
+          const term = data[i]
+          if (term == null) {
+            throw new Error(
+              `cipherstash v3 encryptQuery(${queryType}): client returned a null term for a non-null value ` +
+                `on "${routingKey.table}"."${routingKey.column}".`,
+            )
+          }
+          results[slot.index] = term
+        })
+      }
+
+      // JSON containment terms go through the single-call path — the
+      // batch operation is scalar-only (it never mints ste_vec terms);
+      // this mirrors stack-drizzle's JSON containment usage exactly.
+      await Promise.all(
+        jsonTerms.map(async (slot) => {
+          // Cast rationale: see the scalar branch above.
+          const result = await client.encryptQuery(
+            slot.plaintext as never,
+            { table, column, queryType: 'searchableJson' } as never,
+          )
+          const term = unwrap(result, 'encryptQuery(searchableJson)')
+          if (term == null) {
+            throw new Error(
+              'cipherstash v3 encryptQuery(searchableJson): client returned a null term for a non-null needle ' +
+                `on "${routingKey.table}"."${routingKey.column}".`,
+            )
+          }
+          results[slot.index] = term
+        }),
+      )
+
+      return results
+    },
+
+    async decrypt({ ciphertext }) {
+      const result = await client.decrypt(
+        ensureV3Payload(ciphertext, 'decrypt'),
+      )
+      return asSdkPlaintext(unwrap(result, 'decrypt'))
+    },
+
+    async bulkDecrypt({ ciphertexts }) {
+      const payload = ciphertexts.map((data, index) => ({
+        data: ensureV3Payload(data, 'bulkDecrypt', index),
+      }))
+      const result = await client.bulkDecrypt(payload)
+      return unwrap(result, 'bulkDecrypt').map((entry) => {
+        if ('error' in entry && entry.error !== undefined) {
+          throw new Error(
+            `cipherstash v3 bulkDecrypt entry failed: ${String(entry.error)}`,
+          )
+        }
+        return asSdkPlaintext(entry.data)
+      })
+    },
+  }
+}
+
+function unwrap<T>(result: StackResult<T>, op: string): T {
+  if (result.failure) {
+    throw new Error(`cipherstash v3 ${op} failed: ${result.failure.message}`)
+  }
+  return result.data
+}
+
+/**
+ * A v3 cell is a `public.eql_v3_*` domain over `jsonb`, so a decodable
+ * ciphertext is always a parsed JSON document (`v3FromDriver` output) —
+ * reject primitives early with a diagnostic instead of letting the FFI
+ * fail opaquely. Deliberately shallower than the v2 adapter's
+ * `i: { t, c }` envelope check: the v3 payload shape is owned by
+ * protect-ffi's eqlVersion-3 wire and validated there.
+ */
+function ensureV3Payload(
+  value: unknown,
+  kind: 'decrypt' | 'bulkDecrypt',
+  index?: number,
+): object {
+  if (typeof value !== 'object' || value === null) {
+    const where = index === undefined ? '' : ` at index ${index}`
+    throw new Error(
+      `cipherstash v3 ${kind}: ciphertext${where} is not a valid EQL v3 payload ` +
+        '(expected the parsed JSONB document stored in the public.eql_v3_* column).',
+    )
+  }
+  return value
+}
+
+// The framework's `CipherstashSdk.decrypt` is typed `Promise<string>`
+// but every envelope's `parseDecryptedValue` hook narrows the raw value
+// to its concrete plaintext type. Forwarding through this cast keeps
+// the codec-side polymorphism intact across the SDK contract (same
+// pattern as the v2 adapter).
+function asSdkPlaintext(value: unknown): string {
+  return value as string
+}
diff --git a/packages/prisma-next/test/bundling-isolation.test.ts b/packages/prisma-next/test/bundling-isolation.test.ts
index ef4d1dfc..70785822 100644
--- a/packages/prisma-next/test/bundling-isolation.test.ts
+++ b/packages/prisma-next/test/bundling-isolation.test.ts
@@ -104,26 +104,42 @@ const RUNTIME_FORBIDDEN = [
  * which uses content-named `constants-<hash>.mjs`). The cross-plane
  * shared chunk in our output carries pure literal constants (codec
  * id, native types, invariant ids) — sharing them is safe and
- * desirable. `ALLOWED_SHARED_CHUNK_CONTENT_MARKERS` below guards that
+ * desirable. `ALLOWED_SHARED_CHUNK_MARKER_SETS` below guards that
  * the matched chunk's body does not also smuggle runtime-plane logic
  * across the boundary.
  */
 const SHARED_CHUNK_PATTERN = /^chunk-[A-Za-z0-9_-]+\.js$/
 
 /**
- * Identifiers that uniquely fingerprint the shared constants chunk:
- * every shared chunk we accept must export every one of these. If a
- * `chunk-*.js` is shared between planes but does NOT include all of
- * these markers, it is not the constants chunk and the test rightly
+ * Identifiers that uniquely fingerprint an allowed shared chunk: every
+ * shared chunk we accept must export every marker of at least one set.
+ * If a `chunk-*.js` is shared between planes but does NOT match a set,
+ * it is not one of the known-safe metadata chunks and the test rightly
  * fails.
+ *
+ * Two safe-to-share chunks exist today:
+ *
+ *   - the v2 constants chunk (pure codec-id / native-type / invariant
+ *     literals);
+ *   - the v3 catalog chunk (`src/v3/catalog.ts` — per-domain metadata
+ *     derived from the stack's `DOMAIN_REGISTRY`: codec ids, castAs,
+ *     capabilities, index names). The control plane reaches it through
+ *     the v3 authoring constructors, the runtime plane through the v3
+ *     codec descriptors / operators; it carries no SDK, codec, wire, or
+ *     migration behaviour.
  */
-const ALLOWED_SHARED_CHUNK_CONTENT_MARKERS = [
-  'CIPHERSTASH_STRING_CODEC_ID',
-  'CIPHERSTASH_DOUBLE_CODEC_ID',
-  'CIPHERSTASH_BIGINT_CODEC_ID',
-  'CIPHERSTASH_DATE_CODEC_ID',
-  'CIPHERSTASH_BOOLEAN_CODEC_ID',
-  'CIPHERSTASH_JSON_CODEC_ID',
+const ALLOWED_SHARED_CHUNK_MARKER_SETS: ReadonlyArray<readonly string[]> = [
+  // v2 constants chunk
+  [
+    'CIPHERSTASH_STRING_CODEC_ID',
+    'CIPHERSTASH_DOUBLE_CODEC_ID',
+    'CIPHERSTASH_BIGINT_CODEC_ID',
+    'CIPHERSTASH_DATE_CODEC_ID',
+    'CIPHERSTASH_BOOLEAN_CODEC_ID',
+    'CIPHERSTASH_JSON_CODEC_ID',
+  ],
+  // v3 catalog chunk
+  ['V3_DOMAIN_META_BY_CODEC_ID', 'V3_FACTORY_BY_NATIVE_TYPE', 'toV3CodecId'],
 ] as const
 
 interface ChunkFile {
@@ -183,8 +199,8 @@ function isAllowedSharedChunk(chunk: string): boolean {
     return false
   }
   const body = readChunk(chunk).body
-  return ALLOWED_SHARED_CHUNK_CONTENT_MARKERS.every((marker) =>
-    body.includes(marker),
+  return ALLOWED_SHARED_CHUNK_MARKER_SETS.some((markers) =>
+    markers.every((marker) => body.includes(marker)),
   )
 }
 
diff --git a/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
index 01dcc00c..bb4519d7 100644
--- a/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
+++ b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
@@ -14,17 +14,24 @@
  */
 
 import {
+  ColumnRef,
   InsertAst,
   ParamRef,
+  ProjectionItem,
+  SelectAst,
   TableSource,
 } from '@prisma-next/sql-relational-core/ast'
 import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan'
 import { describe, expect, it } from 'vitest'
+import { setHandleRoutingKey } from '../../src/execution/envelope-base'
 import { EncryptedJson } from '../../src/execution/envelope-json'
 import { EncryptedString } from '../../src/execution/envelope-string'
 import { CIPHERSTASH_STRING_CODEC_ID } from '../../src/extension-metadata/constants'
 import { isCipherstashV3CodecId } from '../../src/extension-metadata/constants-v3'
 import { bulkEncryptMiddlewareV3 } from '../../src/v3/bulk-encrypt-v3'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import { markV3QueryTerm } from '../../src/v3/query-term'
+import { v3ToDriver } from '../../src/v3/wire-v3'
 import {
   baseMeta,
   buildInsertPlan,
@@ -33,6 +40,17 @@ import {
   createSqlParamRefMutator,
   makeCounterSdk,
 } from '../bulk-encrypt-middleware.helpers'
+import {
+  callOperator,
+  columnAccessorV3,
+  contractV3,
+  getOperator,
+  INTEGER_ORD_CODEC_ID,
+  literalParamValue,
+  makeV3Adapter,
+  selectWithWhere,
+  TABLE,
+} from './operator-lowering-v3.helpers'
 
 const V3_TEXT_SEARCH = 'cipherstash/eql-v3/eql_v3_text_search@1'
 const V3_JSON = 'cipherstash/eql-v3/eql_v3_json@1'
@@ -308,6 +326,182 @@ describe('bulkEncryptMiddlewareV3', () => {
     })
   })
 
+  describe('query-term params (Task 6 → Task 7 seam)', () => {
+    /**
+     * Build a plan carrying one query-term param: an envelope MARKED by
+     * `markV3QueryTerm` (what the v3 operators do at lowering time),
+     * routing pre-stamped, bound under the bare-rendering `pg/text@1`
+     * codec (never a v3 codec id).
+     */
+    function queryTermPlan(envelope: EncryptedString): SqlExecutionPlan {
+      const ref = ParamRef.of(envelope, { codec: { codecId: 'pg/text@1' } })
+      // A WHERE-operand param lives outside insert/update rows; the AST
+      // shape here only needs to expose the ParamRef to the mutator.
+      const ast = new InsertAst(TableSource.named('user'), [{ email: ref }])
+      return {
+        sql: 'SELECT ... WHERE eql_v3.eq("user"."email", $1::eql_v3.query_text_search)',
+        params: [envelope],
+        meta: { ...baseMeta },
+        ast,
+      } as SqlExecutionPlan
+    }
+
+    it('forwards the MARKED ENVELOPE itself through sdk.bulkEncrypt and writes the term back as JSONB text', async () => {
+      const term = { i: { t: 'user', c: 'email' }, hm: 'term' }
+      const sdk = makeCounterSdk({ encryptImpl: () => [term] })
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      setHandleRoutingKey(envelope, 'user', 'email')
+      markV3QueryTerm(envelope, 'equality')
+      const plan = queryTermPlan(envelope)
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.routingKey).toEqual({
+        table: 'user',
+        column: 'email',
+      })
+      // The envelope travels the seam by IDENTITY, mark intact — the v3
+      // SDK adapter reads it to route through encryptQuery.
+      expect(sdk.bulkEncryptCalls[0]?.values).toEqual([envelope])
+      expect(params.currentParams()[0]).toBe(v3ToDriver(term))
+    })
+
+    it('does NOT stamp the query term into the envelope ciphertext slot', async () => {
+      const sdk = makeCounterSdk({ encryptImpl: () => [{ hm: 'term' }] })
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      setHandleRoutingKey(envelope, 'user', 'email')
+      markV3QueryTerm(envelope, 'freeTextSearch')
+      const plan = queryTermPlan(envelope)
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(envelope.expose().ciphertext).toBeUndefined()
+      expect(envelope.expose().plaintext).toBe('alice@example.com')
+    })
+
+    it('groups a storage value and a query term on the same column into one SDK call, position-stable', async () => {
+      const sdk = makeCounterSdk({
+        encryptImpl: (args) =>
+          args.values.map((value) =>
+            value instanceof EncryptedString
+              ? { term: value.expose().plaintext }
+              : { c: `enc:${String(value)}` },
+          ),
+      })
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const storageEnvelope = EncryptedString.from('new@example.com')
+      const termEnvelope = EncryptedString.from('old@example.com')
+      setHandleRoutingKey(termEnvelope, 'user', 'email')
+      markV3QueryTerm(termEnvelope, 'equality')
+
+      // UPDATE user SET email = $1(storage) WHERE email = $2(term)
+      const storageRef = ParamRef.of(storageEnvelope, {
+        codec: { codecId: V3_TEXT_SEARCH },
+      })
+      const termRef = ParamRef.of(termEnvelope, {
+        codec: { codecId: 'pg/text@1' },
+      })
+      const ast = new InsertAst(TableSource.named('user'), [
+        { email: storageRef },
+        { email: termRef },
+      ])
+      const plan = {
+        sql: 'UPDATE ...',
+        params: [storageEnvelope, termEnvelope],
+        meta: { ...baseMeta },
+        ast,
+      } as SqlExecutionPlan
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      // AST param order: the SET storage value first, the WHERE term
+      // second — the storage value travels as raw plaintext, the query
+      // term as the marked envelope itself.
+      expect(sdk.bulkEncryptCalls[0]?.values).toEqual([
+        'new@example.com',
+        termEnvelope,
+      ])
+      expect(params.currentParams()).toEqual([
+        v3ToDriver({ c: 'enc:new@example.com' }),
+        v3ToDriver({ term: 'old@example.com' }),
+      ])
+      // Storage envelope caches its ciphertext; the term envelope does not.
+      expect(storageEnvelope.expose().ciphertext).toEqual({
+        c: 'enc:new@example.com',
+      })
+      expect(termEnvelope.expose().ciphertext).toBeUndefined()
+    })
+
+    it('throws when a marked envelope has no routing context', async () => {
+      const sdk = makeCounterSdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      markV3QueryTerm(envelope, 'equality')
+      // A WHERE-side param on a SELECT: the insert/update AST walk has
+      // nothing to stamp from and no operator stamped routing.
+      const ref = ParamRef.of(envelope, { codec: { codecId: 'pg/text@1' } })
+      const ast = SelectAst.from(TableSource.named('user'))
+        .withProjection([ProjectionItem.of('id', ColumnRef.of('user', 'id'))])
+        .withWhere(ref)
+      const plan = {
+        sql: 'SELECT "user"."id" FROM "user" WHERE $1',
+        params: [envelope],
+        meta: { ...baseMeta },
+        ast,
+      } as SqlExecutionPlan
+      const params = createSqlParamRefMutator(plan)
+
+      await expect(
+        middleware.beforeExecute?.(plan, createCtx(), params),
+      ).rejects.toThrow(/without a[\s\S]*routing context/)
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+
+    it('END-TO-END: a real cipherstashEq lowering feeds the seam and the param lands as query-term JSONB', async () => {
+      const term = { i: { t: TABLE, c: 'score' }, ob: ['deadbeef'] }
+      const sdk = makeCounterSdk({ encryptImpl: () => [term] })
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+
+      const predicate = callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
+        42,
+      )
+      const ast = selectWithWhere(predicate)
+      const lowered = makeV3Adapter().lower(ast, { contract: contractV3 })
+      const plan = {
+        sql: lowered.sql,
+        params: lowered.params.map(literalParamValue),
+        meta: { ...baseMeta },
+        ast,
+      } as SqlExecutionPlan
+      const params = createSqlParamRefMutator(plan)
+
+      await middleware.beforeExecute?.(plan, createCtx(), params)
+
+      // The operator minted a marked envelope; the middleware forwarded
+      // it by identity under the (user, score) routing key…
+      expect(sdk.bulkEncryptCalls).toHaveLength(1)
+      expect(sdk.bulkEncryptCalls[0]?.routingKey).toEqual({
+        table: TABLE,
+        column: 'score',
+      })
+      const forwarded = sdk.bulkEncryptCalls[0]?.values[0]
+      expect(forwarded).toBeInstanceOf(EncryptedNumber)
+      // …and wrote the resulting term back as the JSONB text the
+      // `$1::eql_v3.query_integer_ord` template consumes.
+      expect(lowered.sql).toContain('::eql_v3.query_integer_ord')
+      expect(params.currentParams()[0]).toBe(v3ToDriver(term))
+    })
+  })
+
   describe('no-op cases', () => {
     it('skips when params is undefined', async () => {
       const sdk = makeV3Sdk()
diff --git a/packages/prisma-next/test/v3/derive-schemas-v3.test.ts b/packages/prisma-next/test/v3/derive-schemas-v3.test.ts
new file mode 100644
index 00000000..9551b9ba
--- /dev/null
+++ b/packages/prisma-next/test/v3/derive-schemas-v3.test.ts
@@ -0,0 +1,178 @@
+/**
+ * `deriveStackSchemasV3` — contract.json → `@cipherstash/stack/eql/v3`
+ * `encryptedTable`s. The v3 twin of `../derive-schemas.test.ts`, with
+ * the v3-specific delta under test: the concrete factory is selected by
+ * the column's `nativeType` (the `public.eql_v3_*` domain), never by
+ * `typeParams` flags — v3 capabilities are intrinsic to the domain.
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  deriveStackSchemasV3,
+  v3ContractColumnEntries,
+} from '../../src/v3/derive-schemas-v3'
+
+// 0.14 contract shape: tables live under storage.namespaces.<ns>.entries.table
+// (the Postgres default namespace is `public`).
+function contract(
+  columns: Record<
+    string,
+    { codecId: string; nativeType?: string; typeParams?: unknown }
+  >,
+  tableName = 'user',
+) {
+  return {
+    storage: {
+      namespaces: {
+        public: { entries: { table: { [tableName]: { columns } } } },
+      },
+    },
+  }
+}
+
+describe('deriveStackSchemasV3', () => {
+  it('derives one v3 EncryptedTable, mapping public.eql_v3_* nativeType -> the concrete factory', () => {
+    const [table] = deriveStackSchemasV3(
+      contract({
+        email: {
+          codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+          nativeType: 'public.eql_v3_text_search',
+        },
+        score: {
+          codecId: 'cipherstash/eql-v3/eql_v3_integer_ord@1',
+          nativeType: 'public.eql_v3_integer_ord',
+        },
+        balance: {
+          codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1',
+          nativeType: 'public.eql_v3_bigint_ord',
+        },
+      }),
+    )
+    expect(table).toBeDefined()
+    const built = table?.build()
+    expect(built?.tableName).toBe('user')
+    // text_search = match + ope + unique (plain `_ord`/`_search` domains
+    // are OPE-backed; only `*_ord_ore` carries `ore`).
+    expect(Object.keys(built?.columns.email?.indexes ?? {}).sort()).toEqual([
+      'match',
+      'ope',
+      'unique',
+    ])
+    expect(Object.keys(built?.columns.score?.indexes ?? {})).toEqual(['ope'])
+    expect(built?.columns.email?.cast_as).toBe('string')
+    expect(built?.columns.score?.cast_as).toBe('number')
+    expect(built?.columns.balance?.cast_as).toBe('bigint')
+  })
+
+  it('derives a types.Json-backed column for public.eql_v3_json (ste_vec)', () => {
+    const [table] = deriveStackSchemasV3(
+      contract({
+        payload: {
+          codecId: 'cipherstash/eql-v3/eql_v3_json@1',
+          nativeType: 'public.eql_v3_json',
+        },
+      }),
+    )
+    const built = table?.build()
+    expect(built?.columns.payload?.cast_as).toBe('json')
+    expect(Object.keys(built?.columns.payload?.indexes ?? {})).toEqual([
+      'ste_vec',
+    ])
+  })
+
+  it('preserves the exact domain on the derived column builders', () => {
+    const [table] = deriveStackSchemasV3(
+      contract({
+        score: {
+          codecId: 'cipherstash/eql-v3/eql_v3_integer_ord@1',
+          nativeType: 'public.eql_v3_integer_ord',
+        },
+      }),
+    )
+    const builders = Object.values(table?.columnBuilders ?? {})
+    expect(builders).toHaveLength(1)
+    expect(builders[0]?.getEqlType()).toBe('public.eql_v3_integer_ord')
+    expect(builders[0]?.getName()).toBe('score')
+  })
+
+  it('skips tables with no v3 columns (v2 codec ids are not v3 columns)', () => {
+    expect(
+      deriveStackSchemasV3(
+        contract({
+          x: {
+            codecId: 'cipherstash/string@1',
+            nativeType: 'eql_v2_encrypted',
+          },
+          y: { codecId: 'pg/text@1', nativeType: 'text' },
+        }),
+      ),
+    ).toHaveLength(0)
+  })
+
+  it('merges tables across namespaces and skips non-v3 tables', () => {
+    const tables = deriveStackSchemasV3({
+      storage: {
+        namespaces: {
+          public: {
+            entries: {
+              table: {
+                user: {
+                  columns: {
+                    email: {
+                      codecId: 'cipherstash/eql-v3/eql_v3_text_eq@1',
+                      nativeType: 'public.eql_v3_text_eq',
+                    },
+                  },
+                },
+                plain: {
+                  columns: {
+                    id: { codecId: 'pg/text@1', nativeType: 'text' },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    })
+    expect(tables.map((t) => t.tableName)).toEqual(['user'])
+  })
+
+  it('throws when a v3 codec id has a nativeType with no eql/v3 factory', () => {
+    expect(() =>
+      deriveStackSchemasV3(
+        contract({
+          email: {
+            codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+            nativeType: 'public.not_a_domain',
+          },
+        }),
+      ),
+    ).toThrow(/maps to no eql\/v3 factory/)
+  })
+
+  it('returns [] for a contract with no storage plane', () => {
+    expect(deriveStackSchemasV3({})).toHaveLength(0)
+  })
+})
+
+describe('v3ContractColumnEntries', () => {
+  it('yields every column with its table, name, codecId, and nativeType', () => {
+    const entries = v3ContractColumnEntries(
+      contract({
+        email: {
+          codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+          nativeType: 'public.eql_v3_text_search',
+        },
+        id: { codecId: 'pg/text@1', nativeType: 'text' },
+      }),
+    )
+    expect(entries).toHaveLength(2)
+    expect(entries).toContainEqual({
+      tableName: 'user',
+      columnName: 'email',
+      codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+      nativeType: 'public.eql_v3_text_search',
+    })
+  })
+})
diff --git a/packages/prisma-next/test/v3/from-stack-divergence-v3.test.ts b/packages/prisma-next/test/v3/from-stack-divergence-v3.test.ts
new file mode 100644
index 00000000..4a02ff4b
--- /dev/null
+++ b/packages/prisma-next/test/v3/from-stack-divergence-v3.test.ts
@@ -0,0 +1,63 @@
+/**
+ * v3 override divergence — `assertV3SchemasAgree` compares EXACT domain
+ * identity (`getEqlType()` → `public.eql_v3_*`), not just cast_as +
+ * index families: `integer_ord` and `integer_ord_ore` share
+ * `cast_as: number` and an ordering index family, but are different
+ * domains with different on-disk CHECKs, so an override swapping one
+ * for the other must throw at setup.
+ */
+
+import { encryptedTable, types } from '@cipherstash/stack/eql/v3'
+import { describe, expect, it } from 'vitest'
+import { assertV3SchemasAgree } from '../../src/v3/from-stack-v3-validate'
+
+describe('v3 override divergence — same cast_as, different domain', () => {
+  it('rejects integer_ord vs integer_ord_ore (both cast_as number)', () => {
+    const derived = encryptedTable('user', { score: types.IntegerOrd('score') })
+    const override = encryptedTable('user', {
+      score: types.IntegerOrdOre('score'),
+    })
+    expect(() => assertV3SchemasAgree(derived, override)).toThrow(/domain/)
+    expect(() => assertV3SchemasAgree(derived, override)).toThrow(
+      /eql_v3_integer_ord_ore/,
+    )
+  })
+
+  it('rejects text_eq vs text_search (both cast_as string)', () => {
+    const derived = encryptedTable('user', { email: types.TextEq('email') })
+    const override = encryptedTable('user', {
+      email: types.TextSearch('email'),
+    })
+    expect(() => assertV3SchemasAgree(derived, override)).toThrow(/domain/)
+  })
+
+  it('accepts an exact domain match', () => {
+    const derived = encryptedTable('user', { score: types.IntegerOrd('score') })
+    const override = encryptedTable('user', {
+      score: types.IntegerOrd('score'),
+    })
+    expect(() => assertV3SchemasAgree(derived, override)).not.toThrow()
+  })
+
+  it('rejects a column missing from the override', () => {
+    const derived = encryptedTable('user', {
+      score: types.IntegerOrd('score'),
+      email: types.TextEq('email'),
+    })
+    const override = encryptedTable('user', {
+      score: types.IntegerOrd('score'),
+    })
+    expect(() => assertV3SchemasAgree(derived, override)).toThrow(/missing/)
+  })
+
+  it('rejects a column the contract does not declare', () => {
+    const derived = encryptedTable('user', {
+      score: types.IntegerOrd('score'),
+    })
+    const override = encryptedTable('user', {
+      score: types.IntegerOrd('score'),
+      email: types.TextEq('email'),
+    })
+    expect(() => assertV3SchemasAgree(derived, override)).toThrow(/missing/)
+  })
+})
diff --git a/packages/prisma-next/test/v3/from-stack-v3.test.ts b/packages/prisma-next/test/v3/from-stack-v3.test.ts
new file mode 100644
index 00000000..e75dee6c
--- /dev/null
+++ b/packages/prisma-next/test/v3/from-stack-v3.test.ts
@@ -0,0 +1,72 @@
+/**
+ * `cipherstashFromStackV3` — the v3-only entry point's validation
+ * paths, all of which throw BEFORE any `EncryptionV3` client is
+ * constructed (so no live CipherStash credentials are needed here; the
+ * happy path is exercised by the live suite).
+ *
+ * Decision 1b pins: a v3 client is v3-only — a contract carrying a v2
+ * cipherstash codec id is a hard error, never a silently-ignored
+ * column; and the v2 `cipherstashFromStack` is a separate, untouched
+ * entry point.
+ */
+
+import { encryptedTable, types } from '@cipherstash/stack/eql/v3'
+import { describe, expect, it } from 'vitest'
+import { cipherstashFromStackV3 } from '../../src/stack/from-stack-v3'
+
+function contract(
+  columns: Record<string, { codecId: string; nativeType?: string }>,
+) {
+  return {
+    storage: {
+      namespaces: {
+        public: { entries: { table: { user: { columns } } } },
+      },
+    },
+  }
+}
+
+describe('cipherstashFromStackV3 — v3-only hard errors', () => {
+  it('rejects a contract carrying v2 cipherstash codec ids', async () => {
+    await expect(
+      cipherstashFromStackV3({
+        contractJson: contract({
+          email: {
+            codecId: 'cipherstash/string@1',
+            nativeType: 'eql_v2_encrypted',
+          },
+          score: {
+            codecId: 'cipherstash/eql-v3/eql_v3_integer_ord@1',
+            nativeType: 'public.eql_v3_integer_ord',
+          },
+        }),
+      }),
+    ).rejects.toThrow(/non-v3 cipherstash codec ids \[cipherstash\/string@1\]/)
+  })
+
+  it('rejects a contract with no v3 cipherstash columns', async () => {
+    await expect(
+      cipherstashFromStackV3({
+        contractJson: contract({
+          id: { codecId: 'pg/text@1', nativeType: 'text' },
+        }),
+      }),
+    ).rejects.toThrow(/no v3 cipherstash columns/)
+  })
+
+  it('rejects an override diverging from the contract on exact domain identity', async () => {
+    await expect(
+      cipherstashFromStackV3({
+        contractJson: contract({
+          score: {
+            codecId: 'cipherstash/eql-v3/eql_v3_integer_ord@1',
+            nativeType: 'public.eql_v3_integer_ord',
+          },
+        }),
+        schemasV3: [
+          encryptedTable('user', { score: types.IntegerOrdOre('score') }),
+        ],
+      }),
+    ).rejects.toThrow(/schema divergence on column "user"\."score"/)
+  })
+})
diff --git a/packages/prisma-next/test/v3/runtime-v3.test.ts b/packages/prisma-next/test/v3/runtime-v3.test.ts
new file mode 100644
index 00000000..e51e5a5f
--- /dev/null
+++ b/packages/prisma-next/test/v3/runtime-v3.test.ts
@@ -0,0 +1,101 @@
+/**
+ * `createCipherstashV3RuntimeDescriptor({ sdk })` — the consumer-facing
+ * v3 wrapper. The v3 twin of `../runtime-descriptor.test.ts`, pinning:
+ *
+ *   - v3's OWN extension identity (decision 1b) — never the v2 space id;
+ *   - the full 40-domain codec surface (including the
+ *     authoring-unexposed `*_ord_ore` variants — the codec layer must
+ *     decode whatever the catalog can name);
+ *   - the `cipherstash:*`-namespaced traits (no framework `equality`);
+ *   - the registered v3 query-operation method set.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import type { CipherstashSdk } from '../../src/execution/sdk'
+import {
+  CIPHERSTASH_SPACE_ID,
+  CIPHERSTASH_STRING_CODEC_ID,
+} from '../../src/extension-metadata/constants'
+import {
+  CIPHERSTASH_V3_CODEC_IDS,
+  CIPHERSTASH_V3_EXTENSION_VERSION,
+  CIPHERSTASH_V3_SPACE_ID,
+} from '../../src/extension-metadata/constants-v3'
+import { cipherstashV3QueryOperations } from '../../src/v3/operators-v3'
+import { createCipherstashV3RuntimeDescriptor } from '../../src/v3/runtime-v3'
+
+function emptySdk(): CipherstashSdk {
+  return {
+    decrypt: vi.fn(),
+    bulkEncrypt: vi.fn(),
+    bulkDecrypt: vi.fn(),
+  }
+}
+
+describe('createCipherstashV3RuntimeDescriptor — descriptor shape', () => {
+  it('declares kind=extension under the v3 id/version (never the v2 id)', () => {
+    const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    expect(descriptor.kind).toBe('extension')
+    expect(descriptor.id).toBe(CIPHERSTASH_V3_SPACE_ID)
+    expect(descriptor.id).not.toBe(CIPHERSTASH_SPACE_ID)
+    expect(descriptor.version).toBe(CIPHERSTASH_V3_EXTENSION_VERSION)
+    expect(descriptor.familyId).toBe('sql')
+    expect(descriptor.targetId).toBe('postgres')
+  })
+
+  it('exposes one codec descriptor per catalog domain (all 40) on both surfaces', () => {
+    const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    const viaTypes = descriptor.types?.codecTypes?.codecDescriptors ?? []
+    const viaCodecs = descriptor.codecs?.() ?? []
+    expect(viaTypes.map((c) => c.codecId).sort()).toEqual(
+      [...CIPHERSTASH_V3_CODEC_IDS].sort(),
+    )
+    expect(viaCodecs.map((c) => c.codecId).sort()).toEqual(
+      [...CIPHERSTASH_V3_CODEC_IDS].sort(),
+    )
+    // Never a v2 codec id.
+    expect(viaCodecs.map((c) => c.codecId)).not.toContain(
+      CIPHERSTASH_STRING_CODEC_ID,
+    )
+  })
+
+  it('every queryable codec carries only cipherstash:* namespaced traits', () => {
+    const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    for (const codec of descriptor.codecs?.() ?? []) {
+      const traits: ReadonlyArray<string> = codec.traits ?? []
+      expect(traits.includes('equality')).toBe(false)
+      for (const trait of traits) {
+        expect(trait.startsWith('cipherstash:')).toBe(true)
+      }
+    }
+  })
+
+  it('registers the full v3 query-operation method set', () => {
+    const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    const methods = Object.keys(descriptor.queryOperations?.() ?? {})
+    expect(methods.sort()).toEqual(
+      Object.keys(cipherstashV3QueryOperations()).sort(),
+    )
+    expect(methods).toContain('cipherstashEq')
+    expect(methods).toContain('cipherstashJsonContains')
+  })
+
+  it('create() returns a target-bound SQL/Postgres instance', () => {
+    const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    const instance = descriptor.create()
+    expect(instance.familyId).toBe('sql')
+    expect(instance.targetId).toBe('postgres')
+  })
+})
+
+describe('createCipherstashV3RuntimeDescriptor — SDK isolation per descriptor', () => {
+  it('produces a different codec instance per invocation so per-tenant SDKs do not cross-talk', () => {
+    const a = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    const b = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
+    const params = { castAs: 'string', capabilities: {} }
+    const codecA = a.codecs?.()[0]?.factory(params)({ name: 'x.y' })
+    const codecB = b.codecs?.()[0]?.factory(params)({ name: 'x.y' })
+    expect(codecA).toBeDefined()
+    expect(codecA).not.toBe(codecB)
+  })
+})
diff --git a/packages/prisma-next/test/v3/sdk-adapter-v3.test.ts b/packages/prisma-next/test/v3/sdk-adapter-v3.test.ts
new file mode 100644
index 00000000..b02fa8a1
--- /dev/null
+++ b/packages/prisma-next/test/v3/sdk-adapter-v3.test.ts
@@ -0,0 +1,405 @@
+/**
+ * Behaviour pins for `createCipherstashV3Sdk`.
+ *
+ * Uses a hand-built fake v3 client (no live ZeroKMS) — every call
+ * returns a deterministic, inspectable result so the adapter's routing,
+ * query-term dispatch, and error-mapping logic can be observed at the
+ * boundary.
+ *
+ * The load-bearing pin is the QUERY-TERM seam (Task 6 → Task 7):
+ * envelopes marked via `markV3QueryTerm` must be encrypted through the
+ * client's `encryptQuery` — batch form for scalar flavours (one
+ * crossing per flavour, mirroring stack-drizzle's v3 `inArray`), single
+ * form for `searchableJson` (mirroring stack-drizzle's JSON containment
+ * path) — while unmarked values take the storage `bulkEncrypt` path.
+ */
+
+import { encryptedTable, types } from '@cipherstash/stack/eql/v3'
+import { describe, expect, it, vi } from 'vitest'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import { markV3QueryTerm } from '../../src/v3/query-term'
+import {
+  type CipherstashV3Client,
+  createCipherstashV3Sdk,
+} from '../../src/v3/sdk-adapter-v3'
+
+function makeUsersTable() {
+  return encryptedTable('users', {
+    email: types.TextSearch('email'),
+    score: types.IntegerOrd('score'),
+    payload: types.Json('payload'),
+  })
+}
+
+interface FakeCalls {
+  bulkEncrypt: Array<{
+    plaintexts: unknown[]
+    table: unknown
+    column: unknown
+  }>
+  encryptQuerySingle: Array<{ plaintext: unknown; opts: unknown }>
+  encryptQueryBatch: Array<unknown[]>
+  decrypt: unknown[]
+  bulkDecrypt: unknown[][]
+}
+
+function makeFakeClient(): { client: CipherstashV3Client; calls: FakeCalls } {
+  const calls: FakeCalls = {
+    bulkEncrypt: [],
+    encryptQuerySingle: [],
+    encryptQueryBatch: [],
+    decrypt: [],
+    bulkDecrypt: [],
+  }
+  const client: CipherstashV3Client = {
+    bulkEncrypt: vi.fn(
+      async (
+        payload: ReadonlyArray<{ plaintext: unknown }>,
+        opts: { table: unknown; column: unknown },
+      ) => {
+        calls.bulkEncrypt.push({
+          plaintexts: payload.map((p) => p.plaintext),
+          table: opts.table,
+          column: opts.column,
+        })
+        return {
+          data: payload.map((p) => ({
+            data: { c: `enc:${String(p.plaintext)}` },
+          })),
+        }
+      },
+    ),
+    decrypt: vi.fn(async (encrypted: unknown) => {
+      calls.decrypt.push(encrypted)
+      return { data: 'pt-single' }
+    }),
+    bulkDecrypt: vi.fn(async (payload: ReadonlyArray<{ data: unknown }>) => {
+      calls.bulkDecrypt.push(payload.map((p) => p.data))
+      return { data: payload.map((_, i) => ({ data: `pt-${i}` })) }
+    }),
+    // The implementation signature is broad; the interface's `never`
+    // params exist only so the REAL generic client satisfies it.
+    encryptQuery: vi.fn(async (first: unknown, opts?: unknown) => {
+      if (opts === undefined) {
+        const terms = first as unknown[]
+        calls.encryptQueryBatch.push(terms)
+        return {
+          data: terms.map((t, i) => ({
+            qt: `term-${i}`,
+            value: (t as { value: unknown }).value,
+          })),
+        }
+      }
+      calls.encryptQuerySingle.push({ plaintext: first, opts })
+      return { data: { qt: 'json-term', value: first } }
+      // Cast rationale: the fake implements both overloads through one
+      // broad body; the interface's `never` params make a direct
+      // assignment impossible without widening here.
+    }) as unknown as CipherstashV3Client['encryptQuery'],
+  }
+  return { client, calls }
+}
+
+describe('createCipherstashV3Sdk — routing-key lookup', () => {
+  it('resolves a (table, column) routing key to the typed v3 schema objects', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const out = await sdk.bulkEncrypt({
+      routingKey: { table: 'users', column: 'email' },
+      values: ['alice'],
+    })
+
+    expect(calls.bulkEncrypt).toHaveLength(1)
+    expect(calls.bulkEncrypt[0]?.table).toBe(users)
+    expect(calls.bulkEncrypt[0]?.column).toBe(users.columnBuilders.email)
+    expect(calls.bulkEncrypt[0]?.plaintexts).toEqual(['alice'])
+    expect(out).toEqual([{ c: 'enc:alice' }])
+  })
+
+  it('throws a clear error for an unknown routing-key table', async () => {
+    const { client } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [makeUsersTable()])
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'audit_log', column: 'message' },
+        values: ['x'],
+      }),
+    ).rejects.toThrow(/routing-key table "audit_log"/)
+  })
+
+  it('throws a clear error for an unknown column on a known table', async () => {
+    const { client } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [makeUsersTable()])
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'nope' },
+        values: ['x'],
+      }),
+    ).rejects.toThrow(/routing-key column "nope"/)
+  })
+})
+
+describe('createCipherstashV3Sdk — query-term routing (Task 6 seam)', () => {
+  it('routes scalar marked envelopes through ONE encryptQuery batch per flavour', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const a = EncryptedNumber.from(1)
+    const b = EncryptedNumber.from(2)
+    markV3QueryTerm(a, 'equality')
+    markV3QueryTerm(b, 'equality')
+
+    const out = await sdk.bulkEncrypt({
+      routingKey: { table: 'users', column: 'score' },
+      values: [a, b],
+    })
+
+    // No storage crossing, exactly one batch crossing.
+    expect(calls.bulkEncrypt).toHaveLength(0)
+    expect(calls.encryptQuerySingle).toHaveLength(0)
+    expect(calls.encryptQueryBatch).toHaveLength(1)
+    expect(calls.encryptQueryBatch[0]).toEqual([
+      {
+        value: 1,
+        table: users,
+        column: users.columnBuilders.score,
+        queryType: 'equality',
+      },
+      {
+        value: 2,
+        table: users,
+        column: users.columnBuilders.score,
+        queryType: 'equality',
+      },
+    ])
+    expect(out).toEqual([
+      { qt: 'term-0', value: 1 },
+      { qt: 'term-1', value: 2 },
+    ])
+  })
+
+  it('routes searchableJson marked envelopes through the single-call encryptQuery path', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const needle = EncryptedJson.from({ role: 'admin' })
+    markV3QueryTerm(needle, 'searchableJson')
+
+    const out = await sdk.bulkEncrypt({
+      routingKey: { table: 'users', column: 'payload' },
+      values: [needle],
+    })
+
+    expect(calls.encryptQueryBatch).toHaveLength(0)
+    expect(calls.encryptQuerySingle).toHaveLength(1)
+    expect(calls.encryptQuerySingle[0]?.plaintext).toEqual({ role: 'admin' })
+    expect(calls.encryptQuerySingle[0]?.opts).toEqual({
+      table: users,
+      column: users.columnBuilders.payload,
+      queryType: 'searchableJson',
+    })
+    expect(out).toEqual([{ qt: 'json-term', value: { role: 'admin' } }])
+  })
+
+  it('keeps mixed storage values and query terms position-stable', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const term = EncryptedString.from('needle')
+    markV3QueryTerm(term, 'freeTextSearch')
+
+    const out = await sdk.bulkEncrypt({
+      routingKey: { table: 'users', column: 'email' },
+      values: ['stored-a', term, 'stored-b'],
+    })
+
+    expect(calls.bulkEncrypt[0]?.plaintexts).toEqual(['stored-a', 'stored-b'])
+    expect(calls.encryptQueryBatch[0]).toEqual([
+      {
+        value: 'needle',
+        table: users,
+        column: users.columnBuilders.email,
+        queryType: 'freeTextSearch',
+      },
+    ])
+    expect(out).toEqual([
+      { c: 'enc:stored-a' },
+      { qt: 'term-0', value: 'needle' },
+      { c: 'enc:stored-b' },
+    ])
+  })
+
+  it('treats an UNMARKED envelope instance as an ordinary storage value', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const unmarked = EncryptedString.from('plain')
+    await sdk.bulkEncrypt({
+      routingKey: { table: 'users', column: 'email' },
+      values: [unmarked],
+    })
+    expect(calls.bulkEncrypt).toHaveLength(1)
+    expect(calls.bulkEncrypt[0]?.plaintexts).toEqual([unmarked])
+    expect(calls.encryptQueryBatch).toHaveLength(0)
+  })
+
+  it('throws when a marked envelope carries no plaintext', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const envelope = EncryptedString.fromInternal({
+      ciphertext: { c: 'pre-existing' },
+      table: 'users',
+      column: 'email',
+      sdk,
+    })
+    markV3QueryTerm(envelope, 'equality')
+
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'email' },
+        values: [envelope],
+      }),
+    ).rejects.toThrow(/no plaintext/)
+  })
+
+  it('throws when the batch returns the wrong number of terms', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    // Cast rationale: overriding the vi.fn mock's broad implementation
+    // signature; the interface's `never` params block direct assignment.
+    client.encryptQuery = (async () => ({
+      data: [],
+    })) as unknown as CipherstashV3Client['encryptQuery']
+    const sdk = createCipherstashV3Sdk(client, [users])
+    const term = EncryptedNumber.from(1)
+    markV3QueryTerm(term, 'equality')
+
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'score' },
+        values: [term],
+      }),
+    ).rejects.toThrow(/returned 0 terms for 1/)
+  })
+
+  it('surfaces an encryptQuery failure as a thrown error', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    // Cast rationale: see above.
+    client.encryptQuery = (async () => ({
+      failure: { message: 'nope' },
+    })) as unknown as CipherstashV3Client['encryptQuery']
+    const sdk = createCipherstashV3Sdk(client, [users])
+    const term = EncryptedNumber.from(1)
+    markV3QueryTerm(term, 'equality')
+
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'score' },
+        values: [term],
+      }),
+    ).rejects.toThrow(/encryptQuery.*failed: nope/)
+  })
+})
+
+describe('createCipherstashV3Sdk — bulkEncrypt error mapping', () => {
+  it('surfaces a bulkEncrypt failure as a thrown error', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    client.bulkEncrypt = async () => ({ failure: { message: 'kaput' } })
+    const sdk = createCipherstashV3Sdk(client, [users])
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'email' },
+        values: ['x'],
+      }),
+    ).rejects.toThrow(/bulkEncrypt failed: kaput/)
+  })
+
+  it('throws when the client returns the wrong number of ciphertexts', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    client.bulkEncrypt = async () => ({ data: [] })
+    const sdk = createCipherstashV3Sdk(client, [users])
+    await expect(
+      sdk.bulkEncrypt({
+        routingKey: { table: 'users', column: 'email' },
+        values: ['x'],
+      }),
+    ).rejects.toThrow(/returned 0 ciphertexts for 1/)
+  })
+})
+
+describe('createCipherstashV3Sdk — decrypt paths', () => {
+  it('decrypt forwards the v3 EQL payload and unwraps the Result', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+    const payload = { c: 'ct', i: { t: 'users', c: 'email' } }
+
+    await expect(
+      sdk.decrypt({ ciphertext: payload, table: 'users', column: 'email' }),
+    ).resolves.toBe('pt-single')
+    expect(calls.decrypt).toEqual([payload])
+  })
+
+  it('decrypt rejects a non-object ciphertext with a v3 diagnostic', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+    await expect(
+      sdk.decrypt({ ciphertext: 'raw-text', table: 'users', column: 'email' }),
+    ).rejects.toThrow(/not a valid EQL v3 payload/)
+  })
+
+  it('bulkDecrypt maps payloads through and unwraps per-entry data', async () => {
+    const users = makeUsersTable()
+    const { client, calls } = makeFakeClient()
+    const sdk = createCipherstashV3Sdk(client, [users])
+
+    const out = await sdk.bulkDecrypt({
+      routingKey: { table: 'users', column: 'email' },
+      ciphertexts: [{ c: 'a' }, { c: 'b' }],
+    })
+    expect(out).toEqual(['pt-0', 'pt-1'])
+    expect(calls.bulkDecrypt).toEqual([[{ c: 'a' }, { c: 'b' }]])
+  })
+
+  it('bulkDecrypt throws on a per-entry error', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    client.bulkDecrypt = async () => ({
+      data: [{ error: 'entry-broke' }],
+    })
+    const sdk = createCipherstashV3Sdk(client, [users])
+    await expect(
+      sdk.bulkDecrypt({
+        routingKey: { table: 'users', column: 'email' },
+        ciphertexts: [{ c: 'a' }],
+      }),
+    ).rejects.toThrow(/entry failed: entry-broke/)
+  })
+
+  it('bulkDecrypt surfaces a whole-call failure', async () => {
+    const users = makeUsersTable()
+    const { client } = makeFakeClient()
+    client.bulkDecrypt = async () => ({ failure: { message: 'downstream' } })
+    const sdk = createCipherstashV3Sdk(client, [users])
+    await expect(
+      sdk.bulkDecrypt({
+        routingKey: { table: 'users', column: 'email' },
+        ciphertexts: [{ c: 'a' }],
+      }),
+    ).rejects.toThrow(/bulkDecrypt failed: downstream/)
+  })
+})
diff --git a/packages/prisma-next/tsup.config.ts b/packages/prisma-next/tsup.config.ts
index 8448346a..75c98f66 100644
--- a/packages/prisma-next/tsup.config.ts
+++ b/packages/prisma-next/tsup.config.ts
@@ -11,6 +11,7 @@ export default defineConfig({
     'src/exports/pack.ts',
     'src/exports/runtime.ts',
     'src/exports/stack.ts',
+    'src/exports/v3.ts',
   ],
   outDir: 'dist',
   format: ['esm'],

From 887088b3d5caa4fcab96572605206b142cad6216 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 14:14:32 -0600
Subject: [PATCH 08/21] feat(prisma-next): EQL v3 bundle baseline migration
 from @cipherstash/eql

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../end-contract.d.ts                         | 175 ++++++++++++++++++
 .../end-contract.json                         | 124 +++++++++++++
 .../migration.json                            |   9 +
 .../migration.ts                              |  85 +++++++++
 .../ops.json                                  |  32 ++++
 .../prisma-next/migrations/refs/head.json     |   5 +-
 packages/prisma-next/package.json             |   1 +
 packages/prisma-next/src/exports/control.ts   |  18 ++
 .../src/migration/eql-bundle-v3.ts            |  21 +++
 .../test/bundling-isolation.test.ts           |  14 +-
 packages/prisma-next/test/descriptor.test.ts  |  44 +++--
 .../prisma-next/test/v3/migration-v3.test.ts  |  79 ++++++++
 pnpm-lock.yaml                                |   3 +
 13 files changed, 596 insertions(+), 14 deletions(-)
 create mode 100644 packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.d.ts
 create mode 100644 packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.json
 create mode 100644 packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
 create mode 100644 packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
 create mode 100644 packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
 create mode 100644 packages/prisma-next/src/migration/eql-bundle-v3.ts
 create mode 100644 packages/prisma-next/test/v3/migration-v3.test.ts

diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.d.ts b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.d.ts
new file mode 100644
index 00000000..6443a1f5
--- /dev/null
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.d.ts
@@ -0,0 +1,175 @@
+// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
+import type {
+  Bit,
+  Char,
+  CodecTypes as PgTypes,
+  Interval,
+  JsonValue,
+  Numeric,
+  Time,
+  Timestamp,
+  Timestamptz,
+  Timetz,
+  VarBit,
+  Varchar,
+} from '@prisma-next/target-postgres/codec-types';
+
+import type {
+  ContractWithTypeMaps,
+  TypeMaps as TypeMapsType,
+} from '@prisma-next/sql-contract/types';
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  NamespaceId,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+export type StorageHash =
+  StorageHashBase<'sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7'>;
+export type ExecutionHash = ExecutionHashBase<string>;
+export type ProfileHash =
+  ProfileHashBase<'sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb'>;
+
+export type CodecTypes = PgTypes;
+export type LaneCodecTypes = CodecTypes;
+export type QueryOperationTypes = PgAdapterQueryOps<CodecTypes>;
+type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
+  ? CodecTypes[CodecId]['output']
+  : _Encoded;
+
+export type FieldOutputTypes = {
+  readonly public: {
+    readonly EqlV2Configuration: {
+      readonly id: CodecTypes['pg/text@1']['output'];
+      readonly state: CodecTypes['pg/text@1']['output'];
+      readonly data: CodecTypes['pg/jsonb@1']['output'];
+    };
+  };
+};
+export type FieldInputTypes = {
+  readonly public: {
+    readonly EqlV2Configuration: {
+      readonly id: CodecTypes['pg/text@1']['input'];
+      readonly state: CodecTypes['pg/text@1']['input'];
+      readonly data: CodecTypes['pg/jsonb@1']['input'];
+    };
+  };
+};
+export type TypeMaps = TypeMapsType<
+  CodecTypes,
+  QueryOperationTypes,
+  FieldOutputTypes,
+  FieldInputTypes
+>;
+
+type ContractBase = Omit<
+  ContractType<{
+    readonly namespaces: {
+      readonly public: {
+        readonly id: 'public';
+        readonly kind: 'sql-namespace';
+        readonly entries: {
+          readonly table: {
+            readonly eql_v2_configuration: {
+              columns: {
+                readonly id: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'pg/text@1';
+                  readonly nullable: false;
+                };
+                readonly state: {
+                  readonly nativeType: 'text';
+                  readonly codecId: 'pg/text@1';
+                  readonly nullable: false;
+                };
+                readonly data: {
+                  readonly nativeType: 'jsonb';
+                  readonly codecId: 'pg/jsonb@1';
+                  readonly nullable: false;
+                };
+              };
+              primaryKey: { readonly columns: readonly ['id'] };
+              uniques: readonly [];
+              indexes: readonly [];
+              foreignKeys: readonly [];
+            };
+          };
+        };
+      };
+    };
+    readonly storageHash: StorageHash;
+  }>,
+  'roots' | 'domain'
+> & {
+  readonly target: 'postgres';
+  readonly targetFamily: 'sql';
+  readonly roots: {
+    readonly eql_v2_configuration: {
+      readonly namespace: 'public' & NamespaceId;
+      readonly model: 'EqlV2Configuration';
+    };
+  };
+  readonly domain: {
+    readonly namespaces: {
+      readonly public: {
+        readonly models: {
+          readonly EqlV2Configuration: {
+            readonly fields: {
+              readonly id: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'pg/text@1' };
+              };
+              readonly state: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'pg/text@1' };
+              };
+              readonly data: {
+                readonly nullable: false;
+                readonly type: { readonly kind: 'scalar'; readonly codecId: 'pg/jsonb@1' };
+              };
+            };
+            readonly relations: Record<string, never>;
+            readonly storage: {
+              readonly table: 'eql_v2_configuration';
+              readonly namespaceId: 'public';
+              readonly fields: {
+                readonly id: { readonly column: 'id' };
+                readonly state: { readonly column: 'state' };
+                readonly data: { readonly column: 'data' };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+  readonly capabilities: {
+    readonly postgres: {
+      readonly distinctOn: true;
+      readonly jsonAgg: true;
+      readonly lateral: true;
+      readonly limit: true;
+      readonly orderBy: true;
+      readonly returning: true;
+    };
+    readonly sql: {
+      readonly defaultInInsert: true;
+      readonly enums: true;
+      readonly lateral: true;
+      readonly returning: true;
+    };
+  };
+  readonly extensionPacks: {};
+  readonly meta: {};
+
+  readonly profileHash: ProfileHash;
+};
+
+export type Contract = ContractWithTypeMaps<ContractBase, TypeMaps>;
+
+export type Namespaces = Contract['storage']['namespaces'];
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.json b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.json
new file mode 100644
index 00000000..8dc56139
--- /dev/null
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/end-contract.json
@@ -0,0 +1,124 @@
+{
+  "schemaVersion": "1",
+  "targetFamily": "sql",
+  "target": "postgres",
+  "profileHash": "sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb",
+  "roots": {
+    "eql_v2_configuration": {
+      "model": "EqlV2Configuration",
+      "namespace": "public"
+    }
+  },
+  "domain": {
+    "namespaces": {
+      "public": {
+        "models": {
+          "EqlV2Configuration": {
+            "fields": {
+              "data": {
+                "nullable": false,
+                "type": {
+                  "codecId": "pg/jsonb@1",
+                  "kind": "scalar"
+                }
+              },
+              "id": {
+                "nullable": false,
+                "type": {
+                  "codecId": "pg/text@1",
+                  "kind": "scalar"
+                }
+              },
+              "state": {
+                "nullable": false,
+                "type": {
+                  "codecId": "pg/text@1",
+                  "kind": "scalar"
+                }
+              }
+            },
+            "relations": {},
+            "storage": {
+              "fields": {
+                "data": {
+                  "column": "data"
+                },
+                "id": {
+                  "column": "id"
+                },
+                "state": {
+                  "column": "state"
+                }
+              },
+              "namespaceId": "public",
+              "table": "eql_v2_configuration"
+            }
+          }
+        }
+      }
+    }
+  },
+  "storage": {
+    "namespaces": {
+      "public": {
+        "entries": {
+          "table": {
+            "eql_v2_configuration": {
+              "columns": {
+                "data": {
+                  "codecId": "pg/jsonb@1",
+                  "nativeType": "jsonb",
+                  "nullable": false
+                },
+                "id": {
+                  "codecId": "pg/text@1",
+                  "nativeType": "text",
+                  "nullable": false
+                },
+                "state": {
+                  "codecId": "pg/text@1",
+                  "nativeType": "text",
+                  "nullable": false
+                }
+              },
+              "foreignKeys": [],
+              "indexes": [],
+              "primaryKey": {
+                "columns": [
+                  "id"
+                ]
+              },
+              "uniques": []
+            }
+          }
+        },
+        "id": "public",
+        "kind": "postgres-schema"
+      }
+    },
+    "storageHash": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7"
+  },
+  "capabilities": {
+    "postgres": {
+      "distinctOn": true,
+      "jsonAgg": true,
+      "lateral": true,
+      "limit": true,
+      "orderBy": true,
+      "returning": true
+    },
+    "sql": {
+      "defaultInInsert": true,
+      "enums": true,
+      "lateral": true,
+      "returning": true
+    }
+  },
+  "extensionPacks": {},
+  "meta": {},
+  "_generated": {
+    "warning": "⚠️  GENERATED FILE - DO NOT EDIT",
+    "message": "This file is automatically generated by \"prisma-next contract emit\".",
+    "regenerate": "To regenerate, run: prisma-next contract emit"
+  }
+}
\ No newline at end of file
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
new file mode 100644
index 00000000..8d45092b
--- /dev/null
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
@@ -0,0 +1,9 @@
+{
+  "from": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7",
+  "to": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7",
+  "providedInvariants": [
+    "cipherstash:install-eql-v3-bundle-v1"
+  ],
+  "createdAt": "2026-07-14T20:10:24.325Z",
+  "migrationHash": "sha256:49917bcf99c88546e4edef9a6323a56045ea522313ee460674e0cc90d747b2c3"
+}
\ No newline at end of file
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
new file mode 100644
index 00000000..41db5b84
--- /dev/null
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
@@ -0,0 +1,85 @@
+#!/usr/bin/env -S node
+/**
+ * CipherStash v3 baseline migration — install the EQL v3 bundle.
+ *
+ * The install SQL is sourced at EMIT time from `@cipherstash/eql/sql`
+ * (see `../../src/migration/eql-bundle-v3.ts` — the same source the
+ * stack's `installEqlV3IfNeeded` uses) and baked into `ops.json`
+ * byte-for-byte. The bundle creates the 40 `public.eql_v3_*` storage
+ * domains, the `eql_v3` operator-function schema (`eql_v3.eq`,
+ * `eql_v3.ord_term`, …), the `eql_v3.query_*` operand domains, and the
+ * `eql_v3_internal` helper schema.
+ *
+ * This is the SECOND migration in the cipherstash contract space, and
+ * it is an **invariant-only edge**: the v3 bundle declares no
+ * contract-space storage (no config table — unlike the v2 bundle's
+ * `eql_v2_configuration`), so the storage hash does not move and
+ * `describe()` returns `from === to === <the v2 baseline's to>`. The
+ * edge exists to carry the `cipherstash:install-eql-v3-bundle-v1`
+ * invariant: the apply-path planner (`findPathWithInvariants`) walks it
+ * when the head ref requires that invariant.
+ *
+ * Authoring loop: this file is hand-edited (see
+ * `docs/architecture docs/adrs/ADR 212 - Contract spaces.md`'s
+ * contract-space package layout section). Re-emit `ops.json` /
+ * `migration.json` after edits via
+ * `pnpm exec tsx migrations/20260601T0100_install_eql_v3_bundle/migration.ts`.
+ */
+import {
+  Migration,
+  MigrationCLI,
+  rawSql,
+} from '@prisma-next/target-postgres/migration'
+import { CIPHERSTASH_V3_INVARIANTS } from '../../src/extension-metadata/constants-v3'
+import {
+  readInstallSql,
+  releaseManifest,
+} from '../../src/migration/eql-bundle-v3'
+
+const INSTALL_LABEL = `Install EQL v3 bundle (eql-${releaseManifest.eqlVersion}: public.eql_v3_* domains + eql_v3.* functions)`
+
+export default class M extends Migration {
+  override describe() {
+    return {
+      from: 'sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7',
+      to: 'sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7',
+    }
+  }
+
+  override get operations() {
+    return [
+      rawSql({
+        id: 'cipherstash.install-eql-v3-bundle',
+        label: INSTALL_LABEL,
+        operationClass: 'additive',
+        invariantId: CIPHERSTASH_V3_INVARIANTS.installBundle,
+        target: { id: 'postgres' },
+        precheck: [],
+        execute: [{ description: INSTALL_LABEL, sql: readInstallSql() }],
+        postcheck: [
+          {
+            description: 'verify the "eql_v3" operator schema exists',
+            sql: "SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3')",
+          },
+          {
+            // The storage domains live in `public` (not `eql_v3`) — by
+            // design, mirroring the v2 `public.eql_v2_encrypted`
+            // rationale: customer data columns declared against the
+            // domains must survive a `DROP SCHEMA eql_v3 CASCADE`
+            // re-install of the operator functions without losing the
+            // columns.
+            description:
+              'verify the concrete domain "public.eql_v3_text_search" exists',
+            sql: "SELECT to_regtype('public.eql_v3_text_search') IS NOT NULL",
+          },
+          {
+            description: 'verify the eql_v3.eq operator function exists',
+            sql: "SELECT EXISTS (SELECT 1 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'eql_v3' AND p.proname = 'eq')",
+          },
+        ],
+      }),
+    ]
+  }
+}
+
+MigrationCLI.run(import.meta.url, M)
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
new file mode 100644
index 00000000..e19060fd
--- /dev/null
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
@@ -0,0 +1,32 @@
+[
+  {
+    "id": "cipherstash.install-eql-v3-bundle",
+    "label": "Install EQL v3 bundle (eql-3.0.0: public.eql_v3_* domains + eql_v3.* functions)",
+    "operationClass": "additive",
+    "invariantId": "cipherstash:install-eql-v3-bundle-v1",
+    "target": {
+      "id": "postgres"
+    },
+    "precheck": [],
+    "execute": [
+      {
+        "description": "Install EQL v3 bundle (eql-3.0.0: public.eql_v3_* domains + eql_v3.* functions)",
+        "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--!       installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--!       access is strictly opt-in. A deployment that exposes EQL to\n--!       non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--!       must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--!       the functions it needs. This is intentional least-privilege, not an\n--!       oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--!       part of the public API and normally needs no grant; where a caller\n--!       reaches an internal object indirectly (a public operator/aggregate\n--!       whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--!       support/constructor/comparator functions, the unsupported-operator\n--!       blockers (which only raise), the aggregate state functions, and the\n--!       SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--!       internal index-term TYPES do not clutter the Supabase Table Builder\n--!       type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--!       here — they are public in `eql_v3` so every operator has a callable\n--!       function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n  'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n  RETURNS name[]\n  LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n  SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n  pgcrypto_schema name;\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n    CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n  END IF;\n\n  SELECT n.nspname INTO pgcrypto_schema\n  FROM pg_extension e\n  JOIN pg_namespace n ON n.oid = e.extnamespace\n  WHERE e.extname = 'pgcrypto';\n\n  IF pgcrypto_schema = 'extensions' THEN\n    -- expected location, nothing to say\n    NULL;\n  ELSIF pgcrypto_schema = 'public' THEN\n    RAISE NOTICE\n      'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n      'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n      'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n  ELSE\n    RAISE EXCEPTION\n      'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n      '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n      'runtime. Relocate the extension before installing EQL: '\n      'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n      pgcrypto_schema;\n  END IF;\nEND $$;\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--!   chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--!   both reached exclusively from plpgsql and btree operator-class support\n--!   contexts, where SQL functions can NEVER be inlined and instead pay the\n--!   per-call SQL-function executor (measured 3.5x the per-call cost of the\n--!   plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--!   caches its plan across calls. The non-array guard preserves the v3\n--!   behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--!   raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--!   so the divergence stays unreachable in practice; JSON null and empty\n--!   array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n  IMMUTABLE\nAS $$\nDECLARE\n  result bytea[];\nBEGIN\n  IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n    RETURN NULL;\n  END IF;\n  SELECT array_agg(decode(value::text, 'hex')::bytea)\n    INTO result\n  FROM jsonb_array_elements_text(val) AS value;\n  RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n  'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n  bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n  terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--!   (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--!   from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--!   SQL-function executor on every compared value in the opclass hot path\n--!   (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--!   non-array guard preserves the v3 behaviour (returns NULL for a\n--!   non-array scalar; the v2 plpgsql original raised); the caller only\n--!   reaches this when `has_ore_block_256(val)` is true, which requires\n--!   `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--!   An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--!   yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--!   The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--!   NULL terms make the comparator return NULL (so an empty-text row silently\n--!   drops out of ordered queries). An empty array instead engages the\n--!   comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--!   non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n  IMMUTABLE\nAS $$\nDECLARE\n  terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n  IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n    RETURN NULL;\n  END IF;\n  SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n    INTO terms\n  FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n  -- plpgsql pitfall: `SELECT <composite> INTO <composite-var>` assigns the\n  -- select-list columns FIELD-WISE into the variable — return the row\n  -- constructor directly instead. The COALESCE stays load-bearing for the\n  -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n  -- the comparator needs an EMPTY terms array, not NULL terms.\n  RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n  'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n  RETURNS eql_v3_internal.ore_block_256\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n    -- entering the body, so no explicit `val IS NULL` guard is needed.\n    IF eql_v3_internal.has_ore_block_256(val) THEN\n      RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n    END IF;\n    RAISE 'Expected an ore index (ob) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--!   this guard treats a present-but-non-array `ob` (a scalar or object) as\n--!   absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--!   structurally invalid `ob` payload at the boundary instead of silently\n--!   degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--!   previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--!   reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--!   both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--!   overloads all are). This deliberately diverges from the v2 originals,\n--!   which carry no volatility marker and so default to `VOLATILE`. The\n--!   comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--!   is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--!   planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--!   the NULL-handling branches below are load-bearing for the array overload.\nCREATE 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)\n  RETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    eq boolean := true;\n    unequal_block smallint := 0;\n    hash_key bytea;\n    data_block bytea;\n    encrypt_block bytea;\n    target_block bytea;\n\n    left_block_size CONSTANT smallint := 16;\n    right_block_size CONSTANT smallint := 32;\n\n    -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n    -- Wire format per term:\n    --   [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n    --   octet_length = 17*N + 16 + 32*N = 49*N + 16  =>  N = (octet_length - 16) / 49\n    -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n    -- (N=14, 702B) with one comparator.\n    n            integer;\n    left_offset  integer;  -- ordinal offset of the first left block (1 + N PRP bytes)\n    right_offset integer;  -- ordinal start of the right CT (= total left CT length = 17*N)\n\n    indicator smallint := 0;\n  BEGIN\n    IF a IS NULL AND b IS NULL THEN\n      RETURN 0;\n    END IF;\n\n    IF a IS NULL THEN\n      RETURN -1;\n    END IF;\n\n    IF b IS NULL THEN\n      RETURN 1;\n    END IF;\n\n    IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n      RAISE EXCEPTION 'Ciphertexts are different lengths';\n    END IF;\n\n    -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n    -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n    -- and derives N = 0, which would fall through to the all-blocks-equal path\n    -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n    IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n      RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n    END IF;\n\n    n := (octet_length(a.bytes) - 16) / 49;\n    left_offset := 1 + n;     -- left blocks begin right after the N PRP bytes\n    right_offset := 17 * n;   -- right CT begins right after the 17*N-byte left CT\n\n    FOR block IN 0..n-1 LOOP\n      -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n      IF\n        substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n        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)\n      THEN\n        IF eq THEN\n          unequal_block := block;\n        END IF;\n        eq = false;\n      END IF;\n    END LOOP;\n\n    IF eq THEN\n      RETURN 0::integer;\n    END IF;\n\n    -- Hash key is the IV from the right CT of b.\n    hash_key := substr(b.bytes, right_offset + 1, 16);\n\n    -- First right block is at right_offset + nonce_size (ordinally indexed).\n    target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n    data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n    encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n    indicator := (\n      get_bit(\n        encrypt_block,\n        0\n      ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n    IF indicator = 1 THEN\n      RETURN 1::integer;\n    ELSE\n      RETURN -1::integer;\n    END IF;\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE 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[])\nRETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    cmp_result integer;\n  BEGIN\n    IF a IS NULL OR b IS NULL THEN\n      RETURN NULL;\n    END IF;\n\n    IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n      RETURN 0;\n    END IF;\n\n    IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n      RETURN -1;\n    END IF;\n\n    IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n      RETURN 1;\n    END IF;\n\n    cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n    IF cmp_result = 0 THEN\n      RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n    END IF;\n\n    RETURN cmp_result;\n  END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n  END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the\n--! domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec\n--! CLLW-*ORE* composite compared by a custom per-byte protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ope_cllw\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The\n--! filter is read from the `bf` field of an encrypted jsonb payload. Native\n--! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain,\n--! so this type needs no custom operators.\n--!\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_timestamp.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars/<T>/.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--!        for TYPE' so unsupported domain operators surface a clear\n--!        error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--!        encrypted_domain_unsupported_bool but typed for blockers shadowing\n--!        native operators whose result is jsonb (#>, -, #-, ||), so composed\n--!        expressions resolve and the body raises rather than failing earlier\n--!        with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--!        encrypted_domain_unsupported_bool but typed for blockers shadowing\n--!        the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal.<T>_ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n  FUNCTION=eql_v3_internal.ore_block_256_eq,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.=),\n  NEGATOR = OPERATOR(public.<>),\n  RESTRICT = eqsel,\n  JOIN = eqjoinsel,\n  HASHES,\n  MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n  FUNCTION=eql_v3_internal.ore_block_256_neq,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<>),\n  NEGATOR = OPERATOR(public.=),\n  RESTRICT = neqsel,\n  JOIN = neqjoinsel,\n  MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n  FUNCTION=eql_v3_internal.ore_block_256_gt,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<),\n  NEGATOR = OPERATOR(public.<=),\n  RESTRICT = scalargtsel,\n  JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n  FUNCTION=eql_v3_internal.ore_block_256_lt,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.>),\n  NEGATOR = OPERATOR(public.>=),\n  RESTRICT = scalarltsel,\n  JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n  FUNCTION=eql_v3_internal.ore_block_256_lte,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.>=),\n  NEGATOR = OPERATOR(public.>),\n  RESTRICT = scalarlesel,\n  JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n  FUNCTION=eql_v3_internal.ore_block_256_gte,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<=),\n  NEGATOR = OPERATOR(public.<),\n  RESTRICT = scalargesel,\n  JOIN = scalargejoinsel\n);\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--!         absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n  RETURNS eql_v3_internal.ope_cllw\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n  'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n  RETURNS eql_v3_internal.hmac_256\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_text.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_text_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_text_match.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_match AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'bf'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_search_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND VALUE ? 'bf'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)';\n\n  --! @brief Encrypted domain public.eql_v3_text_search.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_search AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE ? 'bf'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)';\nEND\n$$;\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--!   NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n  RETURNS eql_v3_internal.bloom_filter\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n    THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n  END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_smallint.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_real.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_real_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_numeric.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_integer.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_double.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_double_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_date.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_date_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_bigint.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector text\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector integer\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_eq\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector text\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector integer\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector text\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector integer\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector text\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector text\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector text\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector integer\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_match AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)';\n\n  --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_search AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector text\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector integer\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_match\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_match\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector text\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector integer\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_eq\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector text\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector text\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector text\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector text\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector integer\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_eq\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector text\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector text\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector text\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector integer\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector text\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector integer\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_eq\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector text\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector text\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector text\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector text\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector integer\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_eq\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector text\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector text\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector integer\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector text\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector text\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector integer\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_eq\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector text\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector text\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector integer\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector text\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector text\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector integer\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_eq\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector text\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector text\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector integer\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector text\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector text\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector integer\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_eq\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_boolean.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_boolean AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector text\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector text\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector text\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector text\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector integer\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_eq\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @file v3/jsonb/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--!   - public.eql_v3_json     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_jsonb_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_jsonb  — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--!         and exactly one string deterministic term (`hm` XOR `op`).\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND jsonb_typeof(val -> 's') = 'string'\n     AND jsonb_typeof(val -> 'c') = 'string'\n     AND (\n       (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op'))\n       OR\n       (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm'))\n     ),\n    false\n  )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--!         string `s`, no ciphertext, and exactly one string term (`hm` XOR\n--!         `op`).\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_jsonb domain CHECK, where a SQL function can never be\n--!   inlined (and the CHECK itself cannot absorb this body — it needs a\n--!   subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--!   caches its plan across calls instead of paying the per-call SQL-function\n--!   executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n  RETURN COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND NOT EXISTS (\n       SELECT 1\n       FROM jsonb_array_elements(\n         CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n       ) AS elem\n       WHERE NOT COALESCE((\n         jsonb_typeof(elem) = 'object'\n         AND jsonb_typeof(elem -> 's') = 'string'\n         AND NOT (elem ? 'c')\n         AND (\n           (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op'))\n           OR\n           (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm'))\n         )\n       ), false)\n     ),\n    false\n  );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--!         `v = 3`, `i`, an `sv` array, and valid sv entry elements.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND val ? 'v'\n     AND val ->> 'v' = '3'\n     AND val ? 'i'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND NOT EXISTS (\n       SELECT 1\n       FROM jsonb_array_elements(\n         CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n       ) AS elem\n       WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n     ),\n    false\n  )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index\n--! metadata). Root `c` is intentionally NOT required — an sv-array root payload\n--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv`\n--! array, so the domain accepts only SteVec **document** payloads and rejects\n--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is\n--! what keeps `public.eql_v3_json` a typed document domain rather than a generic\n--! encrypted envelope. The firewall in blockers.sql attaches to this domain to\n--! stop native jsonb operators from reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"sv\":[...]}'::public.eql_v3_json`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json AS jsonb\n      CHECK (\n        public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for\n--! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually\n--! exclusive. This is the type returned by `->` and accepted by the per-entry\n--! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root\n--! `i`/`v` merged in by `->`) are allowed.\n--!\n--! @see src/v3/jsonb/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb\n      CHECK (\n        VALUE IS NULL\n        OR COALESCE(\n          jsonb_typeof(VALUE) = 'object'\n           AND jsonb_typeof(VALUE -> 's') = 'string'\n           AND jsonb_typeof(VALUE -> 'c') = 'string'\n           AND (\n             (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op'))\n             OR\n             (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm'))\n           ),\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element must carry `s` and\n--! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way\n--! stops selector-only needles from casting and matching every row via bare\n--! `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\",\"hm\":\"<hm>\"}]}'::eql_v3.query_jsonb`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_jsonb`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_jsonb AS jsonb\n      CHECK (\n        public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json to a query_jsonb needle.\n--!\n--! Normalises each sv element down to the matching-relevant fields: `s` plus\n--! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else)\n--! are stripped. This is the canonical needle shape for `@>` containment.\n--! Designed for use as a functional GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json Source encrypted payload\n--! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_jsonb\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json)\n  RETURNS eql_v3.query_jsonb\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(\n                jsonb_strip_nulls(\n                  jsonb_build_object(\n                    's',  elem -> 's',\n                    'hm', elem -> 'hm',\n                    'op', elem -> 'op'\n                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_jsonb\n$$;\n\nCREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb)\n  WITH FUNCTION eql_v3.to_ste_vec_query\n  AS ASSIGNMENT;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector text\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector integer\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector text\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector integer\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param selector public.eql_v3_text\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param selector public.eql_v3_text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector text\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector integer\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector text\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector integer\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param selector public.eql_v3_real\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param selector public.eql_v3_real\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--!       CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--!       integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--!       the installer as a non-superuser role, so the DO block below ATTEMPTS\n--!       the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--!       letting the single installer run everywhere. When the class is absent,\n--!       ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--!       but the order-preserving (OPE) ordering domains — whose extractor\n--!       return types carry a native btree opclass — still index without it. On\n--!       superuser installs (self-managed Postgres, the SQLx test matrix) the\n--!       class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n  EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n  EXECUTE $ddl$\n    CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n      DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n      USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n        OPERATOR 1 public.<,\n        OPERATOR 2 public.<=,\n        OPERATOR 3 public.=,\n        OPERATOR 4 public.>=,\n        OPERATOR 5 public.>,\n        FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n  $ddl$;\n\n  RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n  WHEN insufficient_privilege THEN\n    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';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector text\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector integer\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector text\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector integer\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector text\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector integer\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param selector public.eql_v3_double\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param selector public.eql_v3_double\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector text\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector integer\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param selector public.eql_v3_date\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param selector public.eql_v3_date\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector text\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector integer\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param selector public.eql_v3_boolean\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param selector public.eql_v3_boolean\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector text\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector integer\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @file v3/jsonb/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--!        eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract metadata (i, v) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i` and `v` fields.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_build_object('i', val->'i', 'v', val->'v');\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n  'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text Base64-encoded ciphertext.\n--! @throws Exception if `c` is absent.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 'c' THEN\n      RETURN val->>'c';\n    END IF;\n    RAISE 'Expected a ciphertext (c) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 's' THEN\n      RETURN val->>'s';\n    END IF;\n    RAISE 'Expected a selector index (s) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--!        guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_jsonb_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Equality-term extractor (XOR-aware: coalesce(hm, op))\n------------------------------------------------------------------------------\n\n--! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry.\n--!\n--! Returns the bytea of whichever deterministic term the sv entry carries —\n--! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint\n--! by construction, so byte equality on the coalesce is unambiguous. Canonical\n--! equality extractor used by `=` / `<>` on jsonb_entry.\n--!\n--! @param entry public.eql_v3_jsonb_entry\n--! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex')\n$$;\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_jsonb_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--!         `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry)\n  RETURNS eql_v3_internal.ope_cllw\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n  RETURNS jsonb[]\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb;\n    ary jsonb[];\n  BEGIN\n    IF val ? 'sv' THEN\n      sv := val->'sv';\n    ELSE\n      sv := jsonb_build_array(val);\n    END IF;\n\n    SELECT array_agg(elem)\n      INTO ary\n      FROM jsonb_array_elements(sv) AS elem;\n\n    RETURN ary;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 'a' THEN\n      RETURN (val->>'a')::boolean;\n    END IF;\n    RETURN false;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic search fields (s, hm, op) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT ARRAY(\n    SELECT jsonb_object_agg(kv.key, kv.value)\n    FROM jsonb_array_elements(\n      CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n    ) AS elem,\n    LATERAL jsonb_each(elem) AS kv(key, value)\n    WHERE kv.key IN ('s', 'hm', 'op')\n    GROUP BY elem\n  );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n  'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--!       deterministic fields — the function-form entrypoint for containment on\n--!       platforms without operator support (Supabase/PostgREST). The typed\n--!       `public.eql_v3_json` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.ste_vec_contains` instead — but both agree on the result (a\n--!       parity test pins this). Also the documented GIN index expression\n--!       (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n  'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--!       entrypoint for `<@` on platforms without operator support. The typed\n--!       `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead,\n--!       but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n  'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm,\n--! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms\n--! are deterministic and byte-disjoint, so either one is a valid equality\n--! discriminator and a single byte comparison is correct.\n--!\n--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte\n--! distributions never collide at a given selector. The crypto layer configures\n--! a selector for eq XOR ordered, so both sides of a real comparison carry the\n--! same term type — an hm needle never meets an op leaf at the same selector.\n--! This collapse would wrongly match an hm needle against an op leaf if their\n--! hex bytes were ever identical — which the contract prevents (an hm is a\n--! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a\n--! function of the plaintext bit width, never 32 bytes for the supported\n--! domains). The negative-containment test guards against regression.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b is found in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    result boolean;\n    _a jsonb;\n  BEGIN\n    result := false;\n\n    FOR idx IN 1..array_length(a, 1) LOOP\n      _a := a[idx];\n      result := result OR (\n        eql_v3.selector(_a) = eql_v3.selector(b)\n        AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry)\n      );\n      EXIT WHEN result;\n    END LOOP;\n\n    RETURN result;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must match selector + eq_term\n--! in some element of a.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_json Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.ste_vec_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    result boolean;\n    sv_a jsonb[];\n    sv_b jsonb[];\n    _b jsonb;\n  BEGIN\n    sv_a := eql_v3.ste_vec(a);\n    sv_b := eql_v3.ste_vec(b);\n\n    IF array_length(sv_b, 1) IS NULL THEN\n      RETURN true;\n    END IF;\n\n    IF array_length(sv_a, 1) IS NULL THEN\n      RETURN false;\n    END IF;\n\n    result := true;\n\n    FOR idx IN 1..array_length(sv_b, 1) LOOP\n      _b := sv_b[idx];\n      result := result AND eql_v3.ste_vec_contains(sv_a, _b);\n    END LOOP;\n\n    RETURN result;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_jsonb_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n  RETURNS SETOF public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry\n  FROM jsonb_array_elements(val -> 'sv') elem\n  WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT EXISTS (\n    SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n    WHERE elem ->> 's' = selector\n  );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_jsonb_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry\n  FROM jsonb_array_elements(val -> 'sv') elem\n  WHERE elem ->> 's' = selector\n  LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n  RETURNS integer\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n  BEGIN\n    IF eql_v3_internal.is_ste_vec_array(val) THEN\n      sv := eql_v3.ste_vec(val);\n      RETURN array_length(sv, 1);\n    END IF;\n\n    RAISE 'cannot get array length of a non-array';\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n  RETURNS SETOF public.eql_v3_jsonb_entry\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n    meta jsonb;\n    item jsonb;\n  BEGIN\n    IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n      RAISE 'cannot extract elements from non-array';\n    END IF;\n\n    meta := eql_v3.meta_data(val);\n    sv := eql_v3.ste_vec(val);\n\n    FOR idx IN 1..array_length(sv, 1) LOOP\n      item = sv[idx];\n      RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as ciphertext text.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF text One ciphertext per element.\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb)\n  RETURNS SETOF text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n  BEGIN\n    IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n      RAISE 'cannot extract elements from non-array';\n    END IF;\n\n    sv := eql_v3.ste_vec(val);\n\n    FOR idx IN 1..array_length(sv, 1) LOOP\n      RETURN NEXT eql_v3.ciphertext(sv[idx]);\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.0 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT '3.0.0';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.0';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_search_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_search_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_search,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_search,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent (CIP-3468).\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n  IF EXISTS (\n    SELECT 1\n    FROM pg_catalog.pg_opclass c\n    JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n    WHERE am.amname = 'btree'\n      AND c.opcdefault\n      AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n  ) THEN\n    RETURN;\n  END IF;\n\n  --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n  --!        without the ORE operator class. Always raises; never returns.\n  --! @internal\n  CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\n  LANGUAGE plpgsql\n  AS $poison$\n  BEGIN\n    RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n      USING HINT = 'Use ' || alternatives || ' instead.',\n            ERRCODE = 'feature_not_supported';\n  END;\n  $poison$;\n  -- NOT VALID: skip validating existing stored data (rows written under an\n  -- earlier superuser install must stay readable, and re-installing over them\n  -- must not abort). Domain coercion still enforces the CHECK on every new\n  -- cast/insert regardless of validation status.\n\n  ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n  RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--!   * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--!   * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--!     index expressions)\n--!   * No `SET` clauses (e.g. `SET search_path = ...`)\n--!   * Not `SECURITY DEFINER`\n--!   * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--!   `error`   — fixable, blocks index matching, ship-blocking.\n--!   `warning` — likely-fixable, may not block matching but signals intent.\n--!   `info`    — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--!   `inlinability_language`   — implementation function isn't `LANGUAGE sql`.\n--!   `inlinability_volatility` — implementation function is VOLATILE.\n--!   `inlinability_set_clause` — implementation function has a `SET` clause.\n--!   `inlinability_secdef`     — implementation function is `SECURITY DEFINER`.\n--!   `inlinability_transitive` — implementation function is itself inlinable\n--!                                but its body invokes a non-inlinable function\n--!                                (depth 1; the planner can't peek through\n--!                                that boundary).\n--!   `blocker_language`        — encrypted-domain blocker is not LANGUAGE\n--!                                plpgsql. The planner can inline / elide a\n--!                                LANGUAGE sql body when the result is\n--!                                provably unused, silently bypassing the\n--!                                RAISE that the blocker exists to perform.\n--!   `blocker_strict`          — encrypted-domain blocker is STRICT.\n--!                                PostgreSQL skips the body and returns NULL\n--!                                on NULL arguments, silently bypassing the\n--!                                RAISE.\n--!   `domain_over_domain`      — an `eql_v3` encrypted domain is derived from\n--!                                another encrypted domain rather than jsonb.\n--!                                Operators resolve against the ultimate base\n--!                                type, so the derived domain does not\n--!                                inherit the base domain's blocker surface.\n--!   `domain_opclass`          — an operator class is declared FOR TYPE on an\n--!                                `eql_v3` encrypted domain. Opclasses on\n--!                                domains bypass operator resolution; use a\n--!                                functional index on the extractor instead.\n--!   `schema_placement`        — a naked composite or enum TYPE lives in the\n--!                                public `eql_v3` schema. Internal index-term\n--!                                types (e.g. `ore_block_256_term`) belong in\n--!                                `eql_v3_internal`; a composite/enum in\n--!                                `eql_v3` clutters the Supabase Table Builder\n--!                                type picker, which the schema split exists to\n--!                                prevent. Move it to `eql_v3_internal`.\n--!\n--! @example\n--! ```\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! ```\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n  severity text,\n  category text,\n  object_name text,\n  message text\n)\nLANGUAGE sql STABLE\nAS $$\n  WITH\n  -- User-column encrypted domains now live in public so application tables\n  -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n  -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n  -- types whose blockers/operator surfaces the lint must understand.\n  encrypted_domain_types AS (\n    SELECT\n      dt.oid AS typid\n    FROM pg_catalog.pg_type dt\n    JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n    JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n    JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n    WHERE dt.typtype = 'd'\n      AND bt.typname = 'jsonb'\n      AND bn.nspname = 'pg_catalog'\n      AND (\n           dn.nspname = 'public'\n        OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n      )\n  ),\n\n  -- All operators where at least one operand is an EQL-owned type or a public\n  -- encrypted domain. Limits the scope of the lint to the operator surface\n  -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n  eql_operators AS (\n    SELECT\n      op.oid              AS oprid,\n      op.oprname          AS opname,\n      op.oprcode          AS implfunc,\n      op.oprleft::regtype AS lhs,\n      op.oprright::regtype AS rhs,\n      op.oprcode::regprocedure AS impl_signature\n    FROM pg_operator op\n    WHERE EXISTS (\n        SELECT 1 FROM pg_type t\n         WHERE t.oid IN (op.oprleft, op.oprright)\n           AND (\n                t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n             OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n           )\n      )\n  ),\n\n  -- Cross-join with each operator's implementation function metadata.\n  -- One row per operator; columns describe the inlinability of the impl.\n  op_impl AS (\n    SELECT\n      eo.opname,\n      eo.lhs,\n      eo.rhs,\n      eo.implfunc                                  AS impl_oid,\n      eo.impl_signature::text                       AS impl_signature,\n      lang_l.lanname                                AS lang,\n      p.provolatile                                 AS volatility,\n      p.proconfig                                   AS config,\n      p.prosecdef                                   AS secdef,\n      p.prosrc                                      AS body\n    FROM eql_operators eo\n    JOIN pg_proc p ON p.oid = eo.implfunc\n    JOIN pg_language lang_l ON lang_l.oid = p.prolang\n  ),\n\n  -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n  -- a blocker marker emitted by the codegen (any of the\n  -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n  -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n  -- literal `is not supported for` for older path-operator blockers) AND\n  -- that take at least one encrypted domain over jsonb argument. The argument\n  -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n  -- helpers themselves, which contain the marker in their body but are not\n  -- blockers (they take text arguments, not a domain).\n  encrypted_domain_blockers AS (\n    SELECT\n      p.oid                                        AS oid,\n      p.oid::regprocedure::text                    AS signature,\n      lang_l.lanname                               AS lang,\n      p.proisstrict                                AS isstrict\n    FROM pg_catalog.pg_proc p\n    JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n    JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n      AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n        OR p.prosrc LIKE '%is not supported for%')\n      AND EXISTS (\n        SELECT 1\n        FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n        JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n      )\n  )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Direct inlinability checks: each row examines one operator's    │\n  -- │ implementation function and emits a violation if any rule is    │\n  -- │ broken. Multiple violations on the same function become         │\n  -- │ multiple rows (developers see every reason it doesn't inline).  │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  SELECT\n    'error'                                                             AS severity,\n    'inlinability_language'                                             AS category,\n    format('operator %s(%s, %s) -> %s',\n           opname, lhs, rhs, impl_signature)                            AS object_name,\n    format(\n      '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.',\n      lang, opname)                                                     AS message\n  FROM op_impl\n  WHERE lang <> 'sql'\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_volatility',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    format(\n      '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).',\n      opname)\n  FROM op_impl\n  WHERE volatility = 'v'\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_set_clause',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    format(\n      '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.')\n  FROM op_impl\n  WHERE config IS NOT NULL\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_secdef',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n  FROM op_impl\n  WHERE secdef\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Transitive inlinability: an operator implementation function    │\n  -- │ that's itself inlinable can still fail to inline if its body    │\n  -- │ calls a non-inlinable function. Walk one level via pg_depend.   │\n  -- │                                                                 │\n  -- │ Postgres records function-to-function dependencies in           │\n  -- │ pg_depend with deptype 'n' (normal) when one function references│\n  -- │ another in its body — but only at CREATE time and only for      │\n  -- │ direct calls. This is good enough for v1; deeper transitive     │\n  -- │ analysis is a follow-up.                                        │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_transitive',\n    format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n           oi.impl_signature),\n    format(\n      '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.',\n      called.proname,\n      called_lang.lanname,\n      CASE called.provolatile\n        WHEN 'i' THEN 'IMMUTABLE'\n        WHEN 's' THEN 'STABLE'\n        WHEN 'v' THEN 'VOLATILE'\n      END,\n      CASE WHEN called.proconfig IS NOT NULL\n           THEN ', has SET clause'\n           ELSE '' END)\n  FROM op_impl oi\n  -- Only worth the transitive check if the outer function is otherwise\n  -- inlinable — otherwise the direct lints above already report it.\n  JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n  JOIN pg_depend d\n    ON d.classid = 'pg_proc'::regclass\n   AND d.objid = outer_p.oid\n   AND d.refclassid = 'pg_proc'::regclass\n   AND d.deptype = 'n'\n  JOIN pg_proc called ON called.oid = d.refobjid\n  JOIN pg_language called_lang ON called_lang.oid = called.prolang\n  WHERE oi.lang = 'sql'\n    AND oi.volatility IN ('i', 's')\n    AND oi.config IS NULL\n    AND NOT oi.secdef\n    AND called.oid <> outer_p.oid\n    AND (\n         called_lang.lanname <> 'sql'\n      OR called.provolatile = 'v'\n      OR called.proconfig IS NOT NULL\n      OR called.prosecdef\n    )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Encrypted-domain footguns: blockers exist to RAISE, so they     │\n  -- │ have inverted inlinability requirements vs operator impls.      │\n  -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT   │\n  -- │ blocker returns NULL on NULL args. Both silently re-enable      │\n  -- │ operators the storage variant is supposed to block.             │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'blocker_language',\n    format('function %s', signature),\n    format(\n      '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.',\n      lang)\n  FROM encrypted_domain_blockers\n  WHERE lang <> 'plpgsql'\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'blocker_strict',\n    format('function %s', signature),\n    'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n  FROM encrypted_domain_blockers\n  WHERE isstrict\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Domain identity: an encrypted-domain must be defined directly   │\n  -- │ over jsonb. Operators resolve against the ultimate base type,   │\n  -- │ so domain-over-domain inherits jsonb's operator surface and not │\n  -- │ the base domain's blockers.                                     │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'domain_over_domain',\n    format('domain %I.%I', dn.nspname, dt.typname),\n    format(\n      '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.',\n      dn.nspname, dt.typname, bn.nspname, bt.typname)\n  FROM pg_catalog.pg_type dt\n  JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n  JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n  JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n  WHERE dt.typtype = 'd'\n    AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n    AND bt.typtype = 'd'\n    AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Domain opclass: an operator class declared FOR TYPE on an       │\n  -- │ encrypted-domain bypasses operator resolution at index time.    │\n  -- │ Use a functional index on the extractor instead.                │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'domain_opclass',\n    format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n    format(\n      '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.',\n      cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n  FROM pg_catalog.pg_opclass oc\n  JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n  JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n  JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n  WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Schema placement: the public `eql_v3` schema must hold only the  │\n  -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n  -- │ there is an internal index-term type in the wrong schema — it     │\n  -- │ clutters the Supabase type picker the split exists to keep clean. │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'schema_placement',\n    format('type %I.%I', n.nspname, t.typname),\n    format(\n      '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      n.nspname, t.typname,\n      CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n  FROM pg_catalog.pg_type t\n  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n  WHERE n.nspname = 'eql_v3'\n    AND t.typtype IN ('c', 'e')\n\n  ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n  'EQL lint: returns one row per non-inlinable operator implementation. '\n  'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n  'CI-gateable check that all operator implementations on eql_v3 types are '\n  'eligible for planner inlining.';\n\n--! @file v3/jsonb/operators.sql\n--! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to\n--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional\n--! index on `eql_v3.eq_term(col -> 'sel')`.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--!   parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--!   A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--!   operator and silently returns native jsonb semantics (a root-key lookup,\n--!   typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json`\n--!   domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--!   native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--!   the domain type-kind and applies to the native-jsonb blockers too. See\n--!   the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json, selector text)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (\n    eql_v3.meta_data(e) ||\n    jsonb_path_query_first(\n      e,\n      '$.sv[*] ? (@.s == $sel)'::jsonpath,\n      jsonb_build_object('sel', selector)\n    )\n  )::public.eql_v3_jsonb_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json, selector integer)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT CASE\n    WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n      -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n      -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare\n      -- untyped literal. The cast documents that intent and guards the `-> selector`\n      -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--!        text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json, selector text)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n  FUNCTION=eql_v3.\"->>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--!        ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json, selector integer)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n  FUNCTION=eql_v3.\"->>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_json Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.ste_vec_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ste_vec_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief @> contains operator with an query_jsonb needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b eql_v3.query_jsonb Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b eql_v3.query_jsonb)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=eql_v3.query_jsonb\n);\n\n--! @brief @> contains operator with a single jsonb_entry needle.\n--!\n--! Wraps the entry into a single-element sv array (stripping `c`) and reduces\n--! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_jsonb_entry Single entry.\n--! @return boolean True if a contains an sv entry matching b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b public.eql_v3_jsonb_entry)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> jsonb_build_object(\n            'sv',\n            jsonb_build_array(\n              jsonb_strip_nulls(\n                jsonb_build_object(\n                  's',  b -> 's',\n                  'hm', b -> 'hm',\n                  'op', b -> 'op'\n                )\n              )\n            )\n          )\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_jsonb_entry\n);\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json Contained value.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ste_vec_contains(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief <@ contained-by operator with an query_jsonb LHS.\n--! @param a eql_v3.query_jsonb Query payload.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_jsonb, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=eql_v3.query_jsonb,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief <@ contained-by operator with a jsonb_entry LHS.\n--! @param a public.eql_v3_jsonb_entry Single entry.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_jsonb_entry, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_jsonb_entry,\n  RIGHTARG=public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality).\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if the entries are equal\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b)\n$$;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = =,\n  NEGATOR  = <>,\n  RESTRICT = eqsel,\n  JOIN     = eqjoinsel\n);\n\n--! @brief Inequality on jsonb_entry via eq_term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if the entries are not equal\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b)\n$$;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <>,\n  NEGATOR  = =,\n  RESTRICT = neqsel,\n  JOIN     = neqjoinsel\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = >,\n  NEGATOR  = >=,\n  RESTRICT = scalarltsel,\n  JOIN     = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = >=,\n  NEGATOR  = >,\n  RESTRICT = scalarlesel,\n  JOIN     = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <,\n  NEGATOR  = <=,\n  RESTRICT = scalargtsel,\n  JOIN     = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\n\n--! @file v3/jsonb/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json.\n--!\n--! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root\n--! document domain.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json document comparisons.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n--! @file v3/jsonb/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_jsonb_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--!   returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--!   `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--!   therefore IGNORE `op`-less entries (they never become or survive as the\n--!   extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--!   `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--!   `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--!   lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--!   row is `op`-less. An all-`op`-less input has no orderable extremum and\n--!   returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_jsonb_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_jsonb_entry Running extremum.\n--! @param value public.eql_v3_jsonb_entry Candidate entry.\n--! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_jsonb_entry,\n  value public.eql_v3_jsonb_entry\n)\nRETURNS public.eql_v3_jsonb_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n  -- A non-orderable (op-less) candidate never replaces the running extremum.\n  IF value_ope IS NULL THEN\n    RETURN state;\n  END IF;\n  -- Adopt the candidate when the running extremum is itself non-orderable\n  -- (e.g. an op-less STRICT seed) or strictly greater.\n  IF state_ope IS NULL OR value_ope < state_ope THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_jsonb_entry.\n--! @param input public.eql_v3_jsonb_entry\n--! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_jsonb_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_jsonb_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_jsonb_entry Running extremum.\n--! @param value public.eql_v3_jsonb_entry Candidate entry.\n--! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_jsonb_entry,\n  value public.eql_v3_jsonb_entry\n)\nRETURNS public.eql_v3_jsonb_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n  -- A non-orderable (op-less) candidate never replaces the running extremum.\n  IF value_ope IS NULL THEN\n    RETURN state;\n  END IF;\n  -- Adopt the candidate when the running extremum is itself non-orderable\n  -- (e.g. an op-less STRICT seed) or strictly lesser.\n  IF state_ope IS NULL OR value_ope > state_ope THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_jsonb_entry.\n--! @param input public.eql_v3_jsonb_entry\n--! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_jsonb_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--!       helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--!       jsonb) and the encrypted-domain family (recognised structurally,\n--!       including public user-column domains) are deliberately left\n--!       unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n  fn_oid oid;\n  inline_critical_oids oid[];\n  jsonb_oid oid;\nBEGIN\n  SELECT t.oid INTO jsonb_oid\n  FROM pg_catalog.pg_type t\n  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n  WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n  IF jsonb_oid IS NULL THEN\n    RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n  END IF;\n\n  -- eql_v3 SEM index-term functions that must stay inlinable for\n  -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n  -- in the legacy combined pin_search_path.sql.\n  SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n  FROM pg_catalog.pg_proc p\n  JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n  WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n    AND (\n      (p.pronargs = 2\n        AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n                          'ore_block_256_lt', 'ore_block_256_lte',\n                          'ore_block_256_gt', 'ore_block_256_gte'))\n      -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n      -- domain over bytea (native comparison operators and btree opclass),\n      -- so there are no ope-specific comparison functions to keep inlinable.\n      OR (p.pronargs = 1\n        AND p.proname = 'ope_cllw'\n        AND p.proargtypes[0] = jsonb_oid)\n      OR (p.pronargs = 1\n        AND p.proname = 'hmac_256'\n        AND p.proargtypes[0] = jsonb_oid)\n      OR (p.pronargs = 1\n        AND p.proname = 'bloom_filter'\n        AND p.proargtypes[0] = jsonb_oid)\n    );\n\n  FOR fn_oid IN\n    SELECT p.oid\n    FROM pg_catalog.pg_proc p\n    JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n      AND p.prokind IN ('f', 'w')\n      AND NOT EXISTS (\n        SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n        WHERE c LIKE 'search_path=%'\n      )\n      AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n      -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n      -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n      -- domains live in public; implementation-only domains live in EQL-owned\n      -- schemas.\n      AND NOT (\n        p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n                     WHERE l.lanname = 'sql')\n        AND p.provolatile = 'i'\n        AND EXISTS (\n          SELECT 1\n          FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n          JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n          JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n          WHERE dt.typtype = 'd'\n            AND dt.typbasetype = jsonb_oid\n            AND (\n              dn.nspname = 'public'\n              OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n            )\n        )\n      )\n      -- Comment-marker fallback for hand-written inline-critical extension\n      -- functions that take no domain argument.\n      AND NOT EXISTS (\n        SELECT 1 FROM pg_catalog.pg_description d\n        WHERE d.objoid = p.oid\n          AND d.classoid = 'pg_catalog.pg_proc'::regclass\n          AND d.description LIKE 'eql-inline-critical%'\n      )\n  LOOP\n    EXECUTE pg_catalog.format(\n      'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n      fn_oid::regprocedure\n    );\n  END LOOP;\nEND $$;\n"
+      }
+    ],
+    "postcheck": [
+      {
+        "description": "verify the \"eql_v3\" operator schema exists",
+        "sql": "SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3')"
+      },
+      {
+        "description": "verify the concrete domain \"public.eql_v3_text_search\" exists",
+        "sql": "SELECT to_regtype('public.eql_v3_text_search') IS NOT NULL"
+      },
+      {
+        "description": "verify the eql_v3.eq operator function exists",
+        "sql": "SELECT EXISTS (SELECT 1 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'eql_v3' AND p.proname = 'eq')"
+      }
+    ]
+  }
+]
\ No newline at end of file
diff --git a/packages/prisma-next/migrations/refs/head.json b/packages/prisma-next/migrations/refs/head.json
index e79526b6..9cb960fe 100644
--- a/packages/prisma-next/migrations/refs/head.json
+++ b/packages/prisma-next/migrations/refs/head.json
@@ -1,4 +1,7 @@
 {
   "hash": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7",
-  "invariants": ["cipherstash:install-eql-bundle-v1"]
+  "invariants": [
+    "cipherstash:install-eql-bundle-v1",
+    "cipherstash:install-eql-v3-bundle-v1"
+  ]
 }
diff --git a/packages/prisma-next/package.json b/packages/prisma-next/package.json
index 01170fc8..dbe0369c 100644
--- a/packages/prisma-next/package.json
+++ b/packages/prisma-next/package.json
@@ -97,6 +97,7 @@
 		"arktype": "^2.1.29"
 	},
 	"devDependencies": {
+		"@cipherstash/eql": "3.0.0",
 		"@prisma-next/adapter-postgres": "0.14.0",
 		"@prisma-next/cli": "0.14.0",
 		"@prisma-next/driver-postgres": "0.14.0",
diff --git a/packages/prisma-next/src/exports/control.ts b/packages/prisma-next/src/exports/control.ts
index 36ba7f83..b037edc2 100644
--- a/packages/prisma-next/src/exports/control.ts
+++ b/packages/prisma-next/src/exports/control.ts
@@ -38,6 +38,12 @@ import baselineMetadata from '../../migrations/20260601T0000_install_eql_bundle/
 import baselineOps from '../../migrations/20260601T0000_install_eql_bundle/ops.json' with {
   type: 'json',
 }
+import v3BaselineMetadata from '../../migrations/20260601T0100_install_eql_v3_bundle/migration.json' with {
+  type: 'json',
+}
+import v3BaselineOps from '../../migrations/20260601T0100_install_eql_v3_bundle/ops.json' with {
+  type: 'json',
+}
 import headRef from '../../migrations/refs/head.json' with { type: 'json' }
 import contractJson from '../contract.json' with { type: 'json' }
 import {
@@ -49,6 +55,7 @@ import {
   CIPHERSTASH_JSON_CODEC_ID,
   CIPHERSTASH_STRING_CODEC_ID,
 } from '../extension-metadata/constants'
+import { CIPHERSTASH_V3_BASELINE_MIGRATION_NAME } from '../extension-metadata/constants-v3'
 import { cipherstashPackMeta } from '../extension-metadata/descriptor-meta'
 import {
   cipherstashBigIntCodecHooks,
@@ -67,6 +74,17 @@ const cipherstashContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({
       metadata: baselineMetadata,
       ops: baselineOps,
     },
+    // The v3 bundle baseline — an invariant-only edge (`from === to`;
+    // the bundle creates `public.eql_v3_*` domains + `eql_v3.*`
+    // functions but no contract-space storage). NO v3 codec id is
+    // registered in `controlPlaneHooks` below: that omission is what
+    // guarantees v3 columns emit no `add_search_config` /
+    // `remove_search_config` ops.
+    {
+      dirName: CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+      metadata: v3BaselineMetadata,
+      ops: v3BaselineOps,
+    },
   ],
   headRef,
 })
diff --git a/packages/prisma-next/src/migration/eql-bundle-v3.ts b/packages/prisma-next/src/migration/eql-bundle-v3.ts
new file mode 100644
index 00000000..4eb9650c
--- /dev/null
+++ b/packages/prisma-next/src/migration/eql-bundle-v3.ts
@@ -0,0 +1,21 @@
+/**
+ * CipherStash EQL v3 install SQL, sourced from `@cipherstash/eql/sql` — the
+ * same source the stack install script (`packages/stack/scripts/install-eql-v3.ts`
+ * / `installEqlV3IfNeeded`) uses. `readInstallSql()` returns the full bundle
+ * that creates the `public.eql_v3_*` domains and the `eql_v3.*` operator
+ * functions; `releaseManifest.eqlVersion` identifies the pinned release.
+ *
+ * The SQL is read at migration EMIT time and baked into the v3 baseline
+ * migration's `ops.json`, so `@cipherstash/eql` stays a devDependency of this
+ * package (not a runtime dependency of the published artefact). Bumping the
+ * pinned `@cipherstash/eql` version requires re-running the maintainer emit
+ * loop for `migrations/20260601T0100_install_eql_v3_bundle/` (see that
+ * migration's header comment) and re-running `test/descriptor.test.ts` /
+ * `test/v3/migration-v3.test.ts`.
+ *
+ * Hash impact: like the v2 bundle (see `./eql-bundle.ts`), the SQL lives in
+ * the migration op's `execute[]`, NOT in `contract.json` — the v3 bundle
+ * declares no contract-space storage, so the edge is invariant-only and
+ * `headRef.hash` does not move.
+ */
+export { readInstallSql, releaseManifest } from '@cipherstash/eql/sql'
diff --git a/packages/prisma-next/test/bundling-isolation.test.ts b/packages/prisma-next/test/bundling-isolation.test.ts
index 70785822..2257c9fa 100644
--- a/packages/prisma-next/test/bundling-isolation.test.ts
+++ b/packages/prisma-next/test/bundling-isolation.test.ts
@@ -117,10 +117,16 @@ const SHARED_CHUNK_PATTERN = /^chunk-[A-Za-z0-9_-]+\.js$/
  * it is not one of the known-safe metadata chunks and the test rightly
  * fails.
  *
- * Two safe-to-share chunks exist today:
+ * Three safe-to-share chunks exist today:
  *
  *   - the v2 constants chunk (pure codec-id / native-type / invariant
  *     literals);
+ *   - the v3 constants chunk (`src/extension-metadata/constants-v3.ts`
+ *     — the pinned v3 codec-id tuple, invariant ids, baseline
+ *     migration name, space id, and the pure `v3TraitsForCapabilities`
+ *     mapper over trait literals). The control plane reaches it through
+ *     the v3 baseline migration wiring in `control.ts`, the runtime
+ *     plane through the v3 codec descriptors;
  *   - the v3 catalog chunk (`src/v3/catalog.ts` — per-domain metadata
  *     derived from the stack's `DOMAIN_REGISTRY`: codec ids, castAs,
  *     capabilities, index names). The control plane reaches it through
@@ -138,6 +144,12 @@ const ALLOWED_SHARED_CHUNK_MARKER_SETS: ReadonlyArray<readonly string[]> = [
     'CIPHERSTASH_BOOLEAN_CODEC_ID',
     'CIPHERSTASH_JSON_CODEC_ID',
   ],
+  // v3 constants chunk
+  [
+    'CIPHERSTASH_V3_CODEC_IDS',
+    'CIPHERSTASH_V3_BASELINE_MIGRATION_NAME',
+    'v3TraitsForCapabilities',
+  ],
   // v3 catalog chunk
   ['V3_DOMAIN_META_BY_CODEC_ID', 'V3_FACTORY_BY_NATIVE_TYPE', 'toV3CodecId'],
 ] as const
diff --git a/packages/prisma-next/test/descriptor.test.ts b/packages/prisma-next/test/descriptor.test.ts
index 96cfe2df..8dd3b346 100644
--- a/packages/prisma-next/test/descriptor.test.ts
+++ b/packages/prisma-next/test/descriptor.test.ts
@@ -32,6 +32,10 @@ import {
   CIPHERSTASH_SPACE_ID,
   EQL_V2_CONFIGURATION_TABLE,
 } from '../src/extension-metadata/constants'
+import {
+  CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+  CIPHERSTASH_V3_INVARIANTS,
+} from '../src/extension-metadata/constants-v3'
 import { EQL_BUNDLE_SQL } from '../src/migration/eql-bundle'
 
 describe('cipherstash extension descriptor (contract-space package layout)', () => {
@@ -61,13 +65,20 @@ describe('cipherstash extension descriptor (contract-space package layout)', ()
     expect(tables).toEqual([EQL_V2_CONFIGURATION_TABLE])
   })
 
-  it('publishes one baseline migration sourced from the on-disk emit pipeline', () => {
+  it('publishes the v2 + v3 baseline migrations sourced from the on-disk emit pipeline', () => {
     const space = cipherstashExtensionDescriptor.contractSpace!
-    expect(space.migrations).toHaveLength(1)
+    expect(space.migrations).toHaveLength(2)
     const baseline = space.migrations[0]!
     expect(baseline.dirName).toBe(CIPHERSTASH_BASELINE_MIGRATION_NAME)
     expect(baseline.metadata.from).toBeNull()
     expect(baseline.metadata.to).toBe(space.contractJson.storage.storageHash)
+    // The v3 baseline is an invariant-only edge: the bundle creates
+    // `public.eql_v3_*` domains + `eql_v3.*` functions but no
+    // contract-space storage, so the hash does not move.
+    const v3Baseline = space.migrations[1]!
+    expect(v3Baseline.dirName).toBe(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME)
+    expect(v3Baseline.metadata.from).toBe(baseline.metadata.to)
+    expect(v3Baseline.metadata.to).toBe(space.contractJson.storage.storageHash)
   })
 
   it('baseline ops carry the installEqlBundle op + structural create-* ops', () => {
@@ -77,13 +88,21 @@ describe('cipherstash extension descriptor (contract-space package layout)', ()
     expect(opIds).toEqual([CIPHERSTASH_INVARIANTS.installBundle])
   })
 
-  it('namespaces every baseline op invariantId under cipherstash:*', () => {
-    const baseline =
-      cipherstashExtensionDescriptor.contractSpace!.migrations[0]!
-    const ids = baseline.ops.map((op) => op.invariantId).filter(Boolean)
-    expect(ids.length).toBeGreaterThan(0)
-    for (const id of ids) {
-      expect(id).toMatch(/^cipherstash:/)
+  it('v3 baseline ops carry the installEqlV3Bundle op only', () => {
+    const space = cipherstashExtensionDescriptor.contractSpace!
+    const v3Baseline = space.migrations[1]!
+    const opIds = v3Baseline.ops.map((op) => op.invariantId).filter(Boolean)
+    expect(opIds).toEqual([CIPHERSTASH_V3_INVARIANTS.installBundle])
+  })
+
+  it('namespaces every op invariantId in every migration under cipherstash:*', () => {
+    for (const migration of cipherstashExtensionDescriptor.contractSpace!
+      .migrations) {
+      const ids = migration.ops.map((op) => op.invariantId).filter(Boolean)
+      expect(ids.length).toBeGreaterThan(0)
+      for (const id of ids) {
+        expect(id).toMatch(/^cipherstash:/)
+      }
     }
   })
 
@@ -99,11 +118,12 @@ describe('cipherstash extension descriptor (contract-space package layout)', ()
     expect(installOp?.execute?.[0]?.sql).toBe(EQL_BUNDLE_SQL)
   })
 
-  it("points the head ref at the latest migration's destination hash", () => {
+  it("points the head ref at the latest migration's destination hash with every migration's invariants", () => {
     const space = cipherstashExtensionDescriptor.contractSpace!
-    expect(space.headRef.hash).toBe(space.migrations[0]!.metadata.to)
+    const latest = space.migrations[space.migrations.length - 1]!
+    expect(space.headRef.hash).toBe(latest.metadata.to)
     expect([...space.headRef.invariants].sort()).toEqual(
-      [...space.migrations[0]!.metadata.providedInvariants].sort(),
+      space.migrations.flatMap((m) => m.metadata.providedInvariants).sort(),
     )
   })
 
diff --git a/packages/prisma-next/test/v3/migration-v3.test.ts b/packages/prisma-next/test/v3/migration-v3.test.ts
new file mode 100644
index 00000000..1521125a
--- /dev/null
+++ b/packages/prisma-next/test/v3/migration-v3.test.ts
@@ -0,0 +1,79 @@
+/**
+ * v3 baseline migration assertions — the on-disk emitted artefacts for
+ * `20260601T0100_install_eql_v3_bundle`.
+ *
+ * The install SQL is sourced at EMIT time from `@cipherstash/eql/sql`
+ * (the same source the stack's `installEqlV3IfNeeded` uses) and baked
+ * into `ops.json` byte-for-byte. The edge is invariant-only: the v3
+ * bundle creates `public.eql_v3_*` domains + `eql_v3.*` functions but
+ * no contract-space storage, so `from === to === <v2 baseline head>`.
+ */
+import { readInstallSql, releaseManifest } from '@cipherstash/eql/sql'
+import { describe, expect, it } from 'vitest'
+import v2Metadata from '../../migrations/20260601T0000_install_eql_bundle/migration.json' with {
+  type: 'json',
+}
+import v3Metadata from '../../migrations/20260601T0100_install_eql_v3_bundle/migration.json' with {
+  type: 'json',
+}
+import v3Ops from '../../migrations/20260601T0100_install_eql_v3_bundle/ops.json' with {
+  type: 'json',
+}
+import headRef from '../../migrations/refs/head.json' with { type: 'json' }
+import { CIPHERSTASH_INVARIANTS } from '../../src/extension-metadata/constants'
+import {
+  CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+  CIPHERSTASH_V3_INVARIANTS,
+} from '../../src/extension-metadata/constants-v3'
+
+describe('v3 baseline migration (20260601T0100_install_eql_v3_bundle)', () => {
+  it('installs under the v3 invariant with a single additive rawSql op', () => {
+    expect(v3Ops).toHaveLength(1)
+    const op = (v3Ops as Array<Record<string, unknown>>)[0]!
+    expect(op.id).toBe('cipherstash.install-eql-v3-bundle')
+    expect(op.invariantId).toBe(CIPHERSTASH_V3_INVARIANTS.installBundle)
+    expect(op.invariantId).toBe('cipherstash:install-eql-v3-bundle-v1')
+    expect(op.operationClass).toBe('additive')
+  })
+
+  it('inlines the @cipherstash/eql install SQL byte-for-byte through ops.json', () => {
+    const op = (
+      v3Ops as ReadonlyArray<{
+        readonly execute?: ReadonlyArray<{ readonly sql: string }>
+      }>
+    )[0]!
+    expect(op.execute?.[0]?.sql).toBe(readInstallSql())
+    expect(releaseManifest.eqlVersion).toBe('3.0.0')
+  })
+
+  it('emits no add_search_config / remove_search_config ops', () => {
+    const json = JSON.stringify(v3Ops)
+    expect(json).not.toContain('add_search_config')
+    expect(json).not.toContain('remove_search_config')
+  })
+
+  it('sorts after the v2 baseline', () => {
+    expect(
+      CIPHERSTASH_V3_BASELINE_MIGRATION_NAME >
+        '20260601T0000_install_eql_bundle',
+    ).toBe(true)
+  })
+
+  it('is an invariant-only edge chained from the v2 baseline head', () => {
+    // The v3 bundle adds no contract-space storage, so the storage hash
+    // does not move: from === to === the v2 baseline's `to`.
+    expect(v3Metadata.from).toBe(v2Metadata.to)
+    expect(v3Metadata.to).toBe(v2Metadata.to)
+    expect(v3Metadata.providedInvariants).toEqual([
+      CIPHERSTASH_V3_INVARIANTS.installBundle,
+    ])
+  })
+
+  it('pins the head ref at the (unchanged) hash with BOTH invariants', () => {
+    expect(headRef.hash).toBe(v3Metadata.to)
+    expect(headRef.invariants).toEqual([
+      CIPHERSTASH_INVARIANTS.installBundle,
+      CIPHERSTASH_V3_INVARIANTS.installBundle,
+    ])
+  })
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ea152ac6..e038e1cf 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -453,6 +453,9 @@ importers:
         specifier: ^2.1.29
         version: 2.2.0
     devDependencies:
+      '@cipherstash/eql':
+        specifier: 3.0.0
+        version: 3.0.0
       '@prisma-next/adapter-postgres':
         specifier: 0.14.0
         version: 0.14.0(typanion@3.14.0)(typescript@5.9.3)

From a3fac7c935f14296d2e580cb20e785cdd26580d8 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 14:25:53 -0600
Subject: [PATCH 09/21] test(prisma-next): property-based suites for v3 wire,
 catalog, and gating

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/package.json             |   1 +
 .../prisma-next/test/v3/properties.test.ts    | 504 ++++++++++++++++++
 pnpm-lock.yaml                                |   3 +
 3 files changed, 508 insertions(+)
 create mode 100644 packages/prisma-next/test/v3/properties.test.ts

diff --git a/packages/prisma-next/package.json b/packages/prisma-next/package.json
index dbe0369c..2c54902a 100644
--- a/packages/prisma-next/package.json
+++ b/packages/prisma-next/package.json
@@ -107,6 +107,7 @@
 		"@prisma-next/sql-contract-ts": "0.14.0",
 		"@prisma-next/sql-schema-ir": "0.14.0",
 		"@prisma-next/target-postgres": "0.14.0",
+		"fast-check": "^4.8.0",
 		"pathe": "^2.0.3",
 		"tsup": "catalog:repo",
 		"typescript": "catalog:repo",
diff --git a/packages/prisma-next/test/v3/properties.test.ts b/packages/prisma-next/test/v3/properties.test.ts
new file mode 100644
index 00000000..5b61111d
--- /dev/null
+++ b/packages/prisma-next/test/v3/properties.test.ts
@@ -0,0 +1,504 @@
+/**
+ * Property-based coverage (fast-check) for the v3 surface — the
+ * cross-cutting invariants the example-based suites pin pointwise:
+ *
+ *   1. WIRE: `v3FromDriver(v3ToDriver(x))` is identity over JSON
+ *      documents (plain-JSONB wire), object passthrough is by
+ *      reference, null/undefined lower to NULL, and stray bigints in a
+ *      malformed envelope serialise as decimal strings instead of
+ *      throwing.
+ *   2. REDACTION: no coercion/serialisation path of an envelope ever
+ *      renders the plaintext — every path is the `[REDACTED]` string or
+ *      the `$encrypted*: "<opaque>"` placeholder.
+ *   3. AUTHORING: constructor ↔ domain totality/bijectivity — every
+ *      exposed catalog domain has exactly one authoring constructor
+ *      whose descriptor equals the catalog values, no constructor maps
+ *      off-catalog, and the pascal/camel name transforms agree and are
+ *      injective.
+ *   4. GATING: capability flags are exactly equivalent to the domain's
+ *      FFI index set (equality ⇔ unique|ope|ore, orderAndRange ⇔
+ *      ope|ore, freeTextSearch ⇔ match, searchableJson ⇔ ste_vec), the
+ *      trait derivation is a bijection with the flags, and every
+ *      (domain × operator) pair is TOTAL: it either lowers to the
+ *      canonical `::eql_v3.query_<domain>` template or throws
+ *      `EncryptionOperatorError` — decided exactly by the capability.
+ *      The finite domain×operator grid is swept exhaustively (stronger
+ *      than sampling); the infinite spaces use fast-check.
+ *   5. DERIVATION: contract column → `deriveStackSchemasV3` →
+ *      derived column's domain identity equals the original for every
+ *      codec id (including the authoring-unexposed `*_ord_ore`
+ *      decode-side domains); foreign codec ids never derive a table.
+ *
+ * No property talks to the network; every case is pure lowering /
+ * catalog / wire code, so the suite stays deterministic-fast at
+ * fast-check's default numRuns.
+ */
+
+import {
+  type AnyExpression,
+  OperationExpr,
+} from '@prisma-next/sql-relational-core/ast'
+import fc from 'fast-check'
+import { describe, expect, it } from 'vitest'
+import {
+  cipherstashAuthoringTypes,
+  v3CamelName,
+  v3PascalName,
+} from '../../src/contract-authoring'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import {
+  CIPHERSTASH_TRAIT_EQUALITY,
+  CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+  CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
+  CIPHERSTASH_TRAIT_SEARCHABLE_JSON,
+  isCipherstashV3CodecId,
+  v3TraitsForCapabilities,
+} from '../../src/extension-metadata/constants-v3'
+import {
+  EXPOSED_DOMAIN_ENTRIES,
+  V3_CODEC_IDS,
+  V3_DOMAIN_META_BY_CODEC_ID,
+  V3_FACTORY_BY_NATIVE_TYPE,
+  type V3CastAs,
+  type V3DomainMeta,
+} from '../../src/v3/catalog'
+import { deriveStackSchemasV3 } from '../../src/v3/derive-schemas-v3'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import {
+  cipherstashV3Asc,
+  cipherstashV3Desc,
+  EncryptionOperatorError,
+} from '../../src/v3/operators-v3'
+import { v3FromDriver, v3ToDriver } from '../../src/v3/wire-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+  TABLE,
+} from './operator-lowering-v3.helpers'
+
+const ALL_DOMAIN_ENTRIES: ReadonlyArray<readonly [string, V3DomainMeta]> = [
+  ...V3_DOMAIN_META_BY_CODEC_ID.entries(),
+]
+
+const EQL_V3_PREFIX = 'eql_v3_'
+
+/** `eql_v3_text_search` → `eql_v3.query_text_search` (regular domains). */
+function expectedQueryCast(meta: V3DomainMeta): string {
+  return `eql_v3.query_${meta.bareDomain.slice(EQL_V3_PREFIX.length)}`
+}
+
+/** Unwrap the lowering template of an operator-built AST node. */
+function templateOf(expr: AnyExpression): string {
+  expect(expr).toBeInstanceOf(OperationExpr)
+  // SqlLoweringSpec's 'function' strategy variant carries the template.
+  const { template } = (expr as OperationExpr).lowering as { template: string }
+  expect(typeof template).toBe('string')
+  return template
+}
+
+/**
+ * Deep-map `-0` to `0`. JSONB **text** cannot carry the sign of a
+ * negative zero (`JSON.stringify(-0)` is `"0"` per ECMA-262), so the
+ * wire round-trip is identity up to this one JSON-semantics
+ * normalization — `fc.jsonValue()` does generate `-0`, and vitest's
+ * `toEqual` distinguishes it via `Object.is`.
+ */
+function withoutNegativeZero(value: unknown): unknown {
+  if (typeof value === 'number') return Object.is(value, -0) ? 0 : value
+  if (Array.isArray(value)) return value.map(withoutNegativeZero)
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, withoutNegativeZero(v)]),
+    )
+  }
+  return value
+}
+
+describe('property: JSONB wire round-trip (v3ToDriver / v3FromDriver)', () => {
+  it('v3FromDriver(v3ToDriver(x)) deep-equals x for arbitrary JSON documents', () => {
+    fc.assert(
+      fc.property(fc.jsonValue(), (x) => {
+        expect(v3FromDriver(v3ToDriver(x))).toEqual(withoutNegativeZero(x))
+      }),
+    )
+  })
+
+  it('null/undefined lower to NULL on encode and are preserved on decode', () => {
+    expect(v3ToDriver(null)).toBeNull()
+    expect(v3ToDriver(undefined)).toBeNull()
+    expect(v3FromDriver(null)).toBeNull()
+    expect(v3FromDriver(undefined)).toBeUndefined()
+  })
+
+  it('pre-parsed jsonb objects pass through decode by reference (pg drivers that parse jsonb)', () => {
+    fc.assert(
+      fc.property(
+        fc.oneof(
+          fc.array(fc.jsonValue()),
+          fc.dictionary(fc.string(), fc.jsonValue()),
+        ),
+        (obj) => {
+          expect(v3FromDriver(obj)).toBe(obj)
+        },
+      ),
+    )
+  })
+
+  it('stray bigints anywhere in a payload encode as decimal strings instead of throwing', () => {
+    // A well-formed envelope never carries a bigint (plaintext is
+    // encrypted to ciphertext strings first), but the wire layer's
+    // bigintSafeReplacer must keep a malformed one from crashing
+    // JSON.stringify — pinned here across nesting positions.
+    fc.assert(
+      fc.property(fc.bigInt(), fc.jsonValue(), (b, doc) => {
+        const decoded = v3FromDriver(
+          v3ToDriver({ stray: b, nested: [b, { deep: b }], doc }),
+        )
+        expect(decoded).toEqual({
+          stray: b.toString(),
+          nested: [b.toString(), { deep: b.toString() }],
+          doc: withoutNegativeZero(doc),
+        })
+      }),
+    )
+  })
+})
+
+describe('property: [REDACTED] invariant (no coercion path leaks plaintext)', () => {
+  it('EncryptedNumber renders the opaque placeholder / [REDACTED] for every double', () => {
+    fc.assert(
+      fc.property(fc.double({ noNaN: true }), (n) => {
+        const env = EncryptedNumber.from(n)
+        expect(JSON.stringify(env)).toBe('{"$encryptedNumber":"<opaque>"}')
+        expect(String(env)).toBe('[REDACTED]')
+        expect(env.valueOf()).toBe('[REDACTED]')
+        expect(`${env}`).not.toContain(String(n))
+      }),
+    )
+  })
+
+  it('EncryptedJson serialises to its placeholder for every JSON document, nested included', () => {
+    fc.assert(
+      fc.property(fc.jsonValue(), (doc) => {
+        const env = EncryptedJson.from(doc)
+        expect(JSON.stringify(env)).toBe('{"$encryptedJson":"<opaque>"}')
+        expect(JSON.stringify({ payload: env })).toBe(
+          '{"payload":{"$encryptedJson":"<opaque>"}}',
+        )
+        expect(String(env)).toBe('[REDACTED]')
+      }),
+    )
+  })
+})
+
+describe('property: constructor ↔ domain totality (authoring namespace)', () => {
+  // Structural view over the namespace: every descriptor is a
+  // typeConstructor with a static output block. The declared
+  // `AuthoringTypeNamespace` value type is a descriptor/namespace union,
+  // so the narrowing goes through `unknown` (test-only view cast).
+  const ns = cipherstashAuthoringTypes.cipherstash as unknown as Record<
+    string,
+    {
+      output: {
+        codecId: string
+        nativeType: string
+        typeParams: { castAs: V3CastAs; capabilities: unknown }
+      }
+    }
+  >
+  const V2_ALIASES = [
+    'EncryptedStringV2',
+    'EncryptedDoubleV2',
+    'EncryptedBigIntV2',
+    'EncryptedDateV2',
+    'EncryptedBooleanV2',
+    'EncryptedJsonV2',
+  ]
+
+  it('every exposed domain has exactly one constructor whose descriptor equals the catalog values', () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...EXPOSED_DOMAIN_ENTRIES),
+        ([codecId, meta]) => {
+          const ctor = ns[v3PascalName(meta.bareDomain)]
+          expect(ctor).toBeDefined()
+          expect(ctor?.output.codecId).toBe(codecId)
+          expect(ctor?.output.nativeType).toBe(meta.nativeType)
+          expect(meta.nativeType.startsWith('public.')).toBe(true)
+          expect(ctor?.output.typeParams.castAs).toBe(meta.castAs)
+          // toEqual treats an absent searchableJson key as equal to an
+          // undefined one, matching capabilitiesTemplate's omission.
+          expect(ctor?.output.typeParams.capabilities).toEqual(
+            meta.capabilities,
+          )
+        },
+      ),
+    )
+  })
+
+  it('no constructor maps off-catalog (v2 aliases excepted) and the counts agree', () => {
+    const validNames = new Set(
+      EXPOSED_DOMAIN_ENTRIES.map(([, m]) => v3PascalName(m.bareDomain)),
+    )
+    for (const name of Object.keys(ns)) {
+      if (name.endsWith('V2')) continue
+      expect(validNames.has(name), `constructor ${name} is off-catalog`).toBe(
+        true,
+      )
+    }
+    expect(
+      Object.keys(ns)
+        .filter((n) => n.endsWith('V2'))
+        .sort(),
+    ).toEqual([...V2_ALIASES].sort())
+    expect(Object.keys(ns)).toHaveLength(
+      EXPOSED_DOMAIN_ENTRIES.length + V2_ALIASES.length,
+    )
+  })
+
+  it('name transforms are injective and pascal/camel agree modulo first-letter case', () => {
+    const pascalNames = EXPOSED_DOMAIN_ENTRIES.map(([, m]) =>
+      v3PascalName(m.bareDomain),
+    )
+    expect(new Set(pascalNames).size).toBe(EXPOSED_DOMAIN_ENTRIES.length)
+    fc.assert(
+      fc.property(fc.constantFrom(...EXPOSED_DOMAIN_ENTRIES), ([, meta]) => {
+        const pascal = v3PascalName(meta.bareDomain)
+        const camel = v3CamelName(meta.bareDomain)
+        expect(pascal.startsWith('Encrypted')).toBe(true)
+        expect(camel).toBe(
+          `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}`,
+        )
+      }),
+    )
+  })
+})
+
+describe('property: capability gating', () => {
+  it('capability flags are exactly the FFI index set for every domain', () => {
+    // GA index split: `unique` (HMAC equality), `ope`/`ore` (ordering —
+    // ordered domains also answer equality via their order term),
+    // `match` (bloom free-text), `ste_vec` (searchable JSON).
+    fc.assert(
+      fc.property(fc.constantFrom(...ALL_DOMAIN_ENTRIES), ([, meta]) => {
+        const has = (key: string) => key in meta.indexes
+        expect(meta.capabilities.equality).toBe(
+          has('unique') || has('ope') || has('ore'),
+        )
+        expect(meta.capabilities.orderAndRange).toBe(has('ope') || has('ore'))
+        expect(meta.capabilities.freeTextSearch).toBe(has('match'))
+        expect(meta.capabilities.searchableJson === true).toBe(has('ste_vec'))
+        // A domain never carries both ordering flavours.
+        expect(has('ope') && has('ore')).toBe(false)
+      }),
+    )
+  })
+
+  it('trait derivation is a bijection with the capability flags (total over arbitrary flag sets)', () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          equality: fc.boolean(),
+          orderAndRange: fc.boolean(),
+          freeTextSearch: fc.boolean(),
+          searchableJson: fc.option(fc.boolean(), { nil: undefined }),
+        }),
+        (caps) => {
+          const traits = v3TraitsForCapabilities(caps)
+          expect(traits.includes(CIPHERSTASH_TRAIT_EQUALITY)).toBe(
+            caps.equality,
+          )
+          expect(traits.includes(CIPHERSTASH_TRAIT_ORDER_AND_RANGE)).toBe(
+            caps.orderAndRange,
+          )
+          expect(traits.includes(CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH)).toBe(
+            caps.freeTextSearch,
+          )
+          expect(traits.includes(CIPHERSTASH_TRAIT_SEARCHABLE_JSON)).toBe(
+            caps.searchableJson === true,
+          )
+          expect(new Set(traits).size).toBe(traits.length)
+        },
+      ),
+    )
+  })
+})
+
+describe('property: operator-gating totality (every domain × every operator)', () => {
+  const SAMPLE_PLAINTEXT: Record<V3CastAs, unknown> = {
+    string: 'alice',
+    number: 42,
+    bigint: 42n,
+    date: new Date('2026-01-02T00:00:00Z'),
+    timestamp: new Date('2026-01-02T03:04:05Z'),
+    boolean: true,
+    json: { role: 'admin' }, // non-empty: the match-all {} needle is rejected
+  }
+
+  type CapabilityKey = keyof V3DomainMeta['capabilities']
+  const OPERATOR_CASES: ReadonlyArray<{
+    method: string
+    capability: CapabilityKey
+    args: (value: unknown) => unknown[]
+  }> = [
+    { method: 'cipherstashEq', capability: 'equality', args: (v) => [v] },
+    { method: 'cipherstashNe', capability: 'equality', args: (v) => [v] },
+    {
+      method: 'cipherstashInArray',
+      capability: 'equality',
+      args: (v) => [[v, v]],
+    },
+    {
+      method: 'cipherstashNotInArray',
+      capability: 'equality',
+      args: (v) => [[v]],
+    },
+    { method: 'cipherstashGt', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'cipherstashGte', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'cipherstashLt', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'cipherstashLte', capability: 'orderAndRange', args: (v) => [v] },
+    {
+      method: 'cipherstashBetween',
+      capability: 'orderAndRange',
+      args: (v) => [v, v],
+    },
+    {
+      method: 'cipherstashNotBetween',
+      capability: 'orderAndRange',
+      args: (v) => [v, v],
+    },
+    {
+      method: 'cipherstashIlike',
+      capability: 'freeTextSearch',
+      args: (v) => [v],
+    },
+    {
+      method: 'cipherstashNotIlike',
+      capability: 'freeTextSearch',
+      args: (v) => [v],
+    },
+    {
+      method: 'cipherstashJsonContains',
+      capability: 'searchableJson',
+      args: (v) => [v],
+    },
+  ]
+
+  it('each pair either lowers with the canonical query cast or throws EncryptionOperatorError, decided by the capability', () => {
+    // The (domain × operator) grid is finite and small (40 × 13), so it
+    // is swept exhaustively — strictly stronger than random sampling.
+    for (const [codecId, meta] of ALL_DOMAIN_ENTRIES) {
+      for (const opCase of OPERATOR_CASES) {
+        const allowed = meta.capabilities[opCase.capability] === true
+        const label = `${meta.bareDomain} × ${opCase.method}`
+        const call = () =>
+          callOperator(
+            getOperator(opCase.method),
+            columnAccessorV3(TABLE, 'c', codecId),
+            ...opCase.args(SAMPLE_PLAINTEXT[meta.castAs]),
+          )
+        if (!allowed) {
+          expect(call, label).toThrow(EncryptionOperatorError)
+          continue
+        }
+        // Totality: a gate-passing domain always has a query cast — the
+        // internal-invariant throw in requireQueryCast must be dead code.
+        const template = templateOf(call())
+        const cast =
+          opCase.method === 'cipherstashJsonContains'
+            ? 'eql_v3.query_jsonb'
+            : expectedQueryCast(meta)
+        expect(template, label).toContain(`::${cast}`)
+      }
+    }
+  })
+
+  it('ordering helpers succeed iff orderAndRange, extracting ord_term_ore exactly on block-ORE domains', () => {
+    for (const [codecId, meta] of ALL_DOMAIN_ENTRIES) {
+      const col = () => columnAccessorV3(TABLE, 'c', codecId)
+      if (!meta.capabilities.orderAndRange) {
+        expect(() => cipherstashV3Asc(col()), meta.bareDomain).toThrow(
+          EncryptionOperatorError,
+        )
+        expect(() => cipherstashV3Desc(col()), meta.bareDomain).toThrow(
+          EncryptionOperatorError,
+        )
+        continue
+      }
+      const fn = 'ore' in meta.indexes ? 'ord_term_ore' : 'ord_term'
+      const asc = cipherstashV3Asc(col())
+      const desc = cipherstashV3Desc(col())
+      expect(asc.dir).toBe('asc')
+      expect(desc.dir).toBe('desc')
+      expect(templateOf(asc.expr), meta.bareDomain).toBe(
+        `eql_v3.${fn}({{self}})`,
+      )
+      expect(templateOf(desc.expr), meta.bareDomain).toBe(
+        `eql_v3.${fn}({{self}})`,
+      )
+    }
+  })
+})
+
+describe('property: derivation round-trip (contract → deriveStackSchemasV3)', () => {
+  function contractFor(codecId: string, nativeType: string) {
+    return {
+      storage: {
+        namespaces: {
+          public: {
+            entries: {
+              table: { user: { columns: { c: { codecId, nativeType } } } },
+            },
+          },
+        },
+      },
+    }
+  }
+
+  it('every codec id derives a column whose domain identity equals the original', () => {
+    fc.assert(
+      fc.property(fc.constantFrom(...ALL_DOMAIN_ENTRIES), ([codecId, meta]) => {
+        const tables = deriveStackSchemasV3(
+          contractFor(codecId, meta.nativeType),
+        )
+        expect(tables).toHaveLength(1)
+        const table = tables[0]
+        expect(table?.tableName).toBe('user')
+        const col = Object.values(table?.columnBuilders ?? {})[0]
+        expect((col as { getEqlType(): string }).getEqlType()).toBe(
+          meta.nativeType,
+        )
+        const builtColumn = table?.build().columns.c
+        expect(builtColumn?.cast_as).toBe(meta.castAs)
+        expect(Object.keys(builtColumn?.indexes ?? {}).sort()).toEqual(
+          Object.keys(meta.indexes).sort(),
+        )
+      }),
+    )
+  })
+
+  it('(codec id) ⟺ (public.* domain) is bijective through the factory map', () => {
+    expect(V3_FACTORY_BY_NATIVE_TYPE.size).toBe(V3_CODEC_IDS.length)
+    fc.assert(
+      fc.property(fc.constantFrom(...ALL_DOMAIN_ENTRIES), ([, meta]) => {
+        const factory = V3_FACTORY_BY_NATIVE_TYPE.get(meta.nativeType)
+        expect(factory).toBeDefined()
+        expect(factory?.('c').getEqlType()).toBe(meta.nativeType)
+      }),
+    )
+  })
+
+  it('arbitrary non-cipherstash codec ids never derive a table', () => {
+    const known = new Set(V3_CODEC_IDS)
+    fc.assert(
+      fc.property(fc.string(), (codecId) => {
+        fc.pre(!known.has(codecId))
+        expect(isCipherstashV3CodecId(codecId)).toBe(false)
+        expect(
+          deriveStackSchemasV3(contractFor(codecId, 'public.eql_v3_text')),
+        ).toHaveLength(0)
+      }),
+    )
+  })
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e038e1cf..154c570c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -483,6 +483,9 @@ importers:
       '@prisma-next/target-postgres':
         specifier: 0.14.0
         version: 0.14.0(typanion@3.14.0)(typescript@5.9.3)
+      fast-check:
+        specifier: ^4.8.0
+        version: 4.8.0
       pathe:
         specifier: ^2.0.3
         version: 2.0.3

From 7bad0b94d52901d02328d8ad9996991d9fb8c37e Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 14:52:10 -0600
Subject: [PATCH 10/21] test(prisma-next): v3 live-PG integration + bundling
 isolation pins
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bundling isolation (test/bundling-isolation.test.ts):
- v3.js joins the entry existence check and is pinned against both the
  contract-space artefacts (RUNTIME_FORBIDDEN) and the v2 wire plane
- content-fingerprinted wire markers (encodeEqlV2EncryptedWire /
  makeCipherstashCellCodec vs CipherstashV3CellCodec /
  createV3CodecDescriptors / bulkEncryptMiddlewareV3): no code-split
  chunk may reference both wire planes, the v3 entry graph never
  reaches the v2 codec-runtime chunk, and middleware.js (v2-only
  entry) never loads the v3 wire

Live-PG suites (test/live/, self-skipping via describeLivePg when
CS creds — env vars or ~/.cipherstash profile — or DATABASE_URL are
absent; `pnpm test:live` convenience script added):
- helpers: live-gate (skip posture), eql-v3 (advisory-locked
  installEqlV3IfNeeded over the Task-8 migration source SQL), harness
  (real cipherstashFromStackV3 + real bulkEncryptMiddlewareV3 driven
  through real execution plans, operator SELECTs lowered by the real
  postgres adapter, envelope fromInternal().decrypt() read path)
- operators-live-pg: eq/ne/inArray, contains (ilike), gt/lte/between,
  date + timestamp ranges, ord_term ordering, JSON containment
  (@> with eql_v3.query_jsonb — ruled decision 2), per-family decrypt
- operators-null-live-pg: NULL cells round-trip, null operands rejected
- boolean-storage-live-pg: storage-only round-trip, operators refuse
- bigint-live-pg: lossless bigint beyond MAX_SAFE_INTEGER, eq/range/order
- migration-apply-live-pg: applied SQL is byte-identical to the shipped
  ops.json, invariant id, domains + eql_v3 schema, op postchecks, no
  add_search_config
- bulk-encrypt-live-pg: real EncryptionV3 through the real middleware,
  JSONB cells, ciphertext stamping, decrypt round-trip
- side-by-side-clients-live-pg: v2 and v3 clients coexisting in-process
  against one database, distinct extension identities and wires

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/package.json             |   2 +
 .../test/bundling-isolation.test.ts           | 124 +++++-
 .../test/live/bigint-live-pg.test.ts          | 179 +++++++++
 .../test/live/boolean-storage-live-pg.test.ts | 104 +++++
 .../test/live/bulk-encrypt-live-pg.test.ts    | 109 ++++++
 .../prisma-next/test/live/helpers/eql-v3.ts   |  62 +++
 .../prisma-next/test/live/helpers/harness.ts  | 357 ++++++++++++++++++
 .../test/live/helpers/live-gate.ts            |  58 +++
 .../test/live/migration-apply-live-pg.test.ts | 129 +++++++
 .../test/live/operators-live-pg.test.ts       | 307 +++++++++++++++
 .../test/live/operators-null-live-pg.test.ts  | 115 ++++++
 .../live/side-by-side-clients-live-pg.test.ts | 230 +++++++++++
 pnpm-lock.yaml                                |   3 +
 13 files changed, 1777 insertions(+), 2 deletions(-)
 create mode 100644 packages/prisma-next/test/live/bigint-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/helpers/eql-v3.ts
 create mode 100644 packages/prisma-next/test/live/helpers/harness.ts
 create mode 100644 packages/prisma-next/test/live/helpers/live-gate.ts
 create mode 100644 packages/prisma-next/test/live/migration-apply-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/operators-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/operators-null-live-pg.test.ts
 create mode 100644 packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts

diff --git a/packages/prisma-next/package.json b/packages/prisma-next/package.json
index 2c54902a..1f65ba29 100644
--- a/packages/prisma-next/package.json
+++ b/packages/prisma-next/package.json
@@ -77,6 +77,7 @@
 		"dev": "tsup --watch",
 		"test": "vitest run",
 		"test:coverage": "vitest run --coverage",
+		"test:live": "vitest run test/live",
 		"typecheck": "tsc --project tsconfig.json --noEmit",
 		"lint": "biome check . --error-on-warnings",
 		"lint:fix": "biome check --write .",
@@ -109,6 +110,7 @@
 		"@prisma-next/target-postgres": "0.14.0",
 		"fast-check": "^4.8.0",
 		"pathe": "^2.0.3",
+		"postgres": "^3.4.8",
 		"tsup": "catalog:repo",
 		"typescript": "catalog:repo",
 		"vitest": "catalog:repo"
diff --git a/packages/prisma-next/test/bundling-isolation.test.ts b/packages/prisma-next/test/bundling-isolation.test.ts
index 2257c9fa..238b6480 100644
--- a/packages/prisma-next/test/bundling-isolation.test.ts
+++ b/packages/prisma-next/test/bundling-isolation.test.ts
@@ -36,7 +36,7 @@
  * the current source.
  */
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'pathe'
 import { describe, expect, it } from 'vitest'
@@ -44,7 +44,12 @@ import { describe, expect, it } from 'vitest'
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
 const DIST = join(PACKAGE_ROOT, 'dist')
 
-const ENTRY_FILES = ['control.js', 'runtime.js', 'middleware.js'] as const
+const ENTRY_FILES = [
+  'control.js',
+  'runtime.js',
+  'middleware.js',
+  'v3.js',
+] as const
 
 /**
  * Forbidden in `control.js` and its transitive chunk graph.
@@ -154,6 +159,35 @@ const ALLOWED_SHARED_CHUNK_MARKER_SETS: ReadonlyArray<readonly string[]> = [
   ['V3_DOMAIN_META_BY_CODEC_ID', 'V3_FACTORY_BY_NATIVE_TYPE', 'toV3CodecId'],
 ] as const
 
+/**
+ * Fingerprints of the v2 WIRE plane — the composite-literal codec
+ * (`encodeEqlV2EncryptedWire` produces the `("...")` wire) and the v2
+ * cell-codec factory built on it. A v3 consumer must never load either:
+ * the v3 wire is plain JSONB (`v3ToDriver`), and mixing the two wire
+ * planes in one module graph is exactly the confusion decision 1b
+ * (a client is v2 or v3, never both) exists to prevent.
+ *
+ * Marker choice notes: `bulkEncryptMiddleware` and `cipherstashFromStack`
+ * are NOT usable as v2 markers — they are substrings of their v3
+ * siblings (`bulkEncryptMiddlewareV3`, `cipherstashFromStackV3`), so a
+ * substring scan would false-positive on every v3 chunk.
+ */
+const V2_WIRE_MARKERS = [
+  'encodeEqlV2EncryptedWire',
+  'makeCipherstashCellCodec',
+] as const
+
+/**
+ * Fingerprints of the v3 WIRE plane — the plain-JSONB cell codec, the
+ * per-domain descriptor factory, and the v3 bulk-encrypt middleware.
+ * A v2-only consumer (the `./middleware` entry) must never load these.
+ */
+const V3_WIRE_MARKERS = [
+  'CipherstashV3CellCodec',
+  'createV3CodecDescriptors',
+  'bulkEncryptMiddlewareV3',
+] as const
+
 interface ChunkFile {
   readonly file: string
   readonly body: string
@@ -258,6 +292,92 @@ describe('bundling isolation', () => {
     ).toEqual([])
   })
 
+  it('v3.js does not pull contract-space artefacts', () => {
+    const entry = readChunk('v3.js')
+    const leaks = findLeaksInEntry(entry, RUNTIME_FORBIDDEN)
+    expect(leaks, `v3 entry leaks: ${leaks.join(', ')}`).toEqual([])
+  })
+
+  it('v3.js does not pull the v2 composite-literal wire', () => {
+    const entry = readChunk('v3.js')
+    const leaks = findLeaksInEntry(entry, V2_WIRE_MARKERS)
+    expect(leaks, `v3 entry leaks v2 wire: ${leaks.join(', ')}`).toEqual([])
+  })
+
+  it('the v3 entry graph never reaches the v2 codec-runtime chunk', () => {
+    // `v3.js` legitimately shares the version-neutral execution chunk
+    // (envelope base/classes, routing, abort, `stampRoutingKeysFromAst`)
+    // with the v2 entries — that chunk currently also DEFINES the v2
+    // wire encoder, which the per-chunk disjointness test below pins.
+    // What must never happen is the v3 graph importing the v2
+    // codec-RUNTIME chunk (the six `createCipherstash*Codec` factories
+    // built on the composite wire).
+    const v3Chunks = collectGraph('v3.js')
+    const offenders = [...v3Chunks.entries()]
+      .filter(([file]) => file !== 'v3.js')
+      .filter(([, chunk]) =>
+        chunk.body.includes('createCipherstashStringCodec'),
+      )
+      .map(([file]) => file)
+    expect(
+      offenders,
+      `v3 graph reaches v2 codec-runtime chunk(s): ${offenders.join(', ')}`,
+    ).toEqual([])
+  })
+
+  it('middleware.js (v2 bulk-encrypt entry) does not pull the v3 wire plane', () => {
+    const entry = readChunk('middleware.js')
+    const leaks = findLeaksInEntry(entry, V3_WIRE_MARKERS)
+    expect(
+      leaks,
+      `middleware entry leaks v3 wire: ${leaks.join(', ')}`,
+    ).toEqual([])
+  })
+
+  it('no code-split chunk mixes the v2 composite wire with the v3 JSONB wire', () => {
+    // Chunk-level two-wires-never-co-located pin. A chunk "references a
+    // wire plane" when any of that plane's marker identifiers appears in
+    // its body — which covers both defining the symbol and importing it
+    // by name from another chunk (`import { encodeEqlV2EncryptedWire }
+    // from "./chunk-*.js"`). Entry files are exempt: `runtime.js` and
+    // `stack.js` deliberately aggregate the v2 AND v3 public API (each
+    // client picks one at construction time); the invariant is that no
+    // shared IMPLEMENTATION chunk fuses the two wire codecs, which is
+    // what would let one wire's encode path silently reach the other's
+    // consumers.
+    const chunkFiles = readdirSync(DIST).filter((f) =>
+      SHARED_CHUNK_PATTERN.test(f),
+    )
+    expect(chunkFiles.length).toBeGreaterThan(0)
+    const mixed = chunkFiles.filter((file) => {
+      const body = readChunk(file).body
+      const referencesV2Wire = V2_WIRE_MARKERS.some((m) => body.includes(m))
+      const referencesV3Wire = V3_WIRE_MARKERS.some((m) => body.includes(m))
+      return referencesV2Wire && referencesV3Wire
+    })
+    expect(
+      mixed,
+      `chunk(s) mix v2 and v3 wire planes: ${mixed.join(', ')}`,
+    ).toEqual([])
+  })
+
+  it('v3-wire chunks reachable from runtime.js never reference the v2 composite encoder', () => {
+    // The plan's original Task-10 assertion, made chunk-name-agnostic:
+    // identify v3 chunks by CONTENT (they carry a v3 wire marker), not
+    // by tsup's hash-named files.
+    const runtimeChunks = collectGraph('runtime.js')
+    for (const [file, chunk] of runtimeChunks) {
+      if (file === 'runtime.js') continue
+      const isV3WireChunk = V3_WIRE_MARKERS.some((m) => chunk.body.includes(m))
+      if (!isV3WireChunk) continue
+      const leaks = V2_WIRE_MARKERS.filter((m) => chunk.body.includes(m))
+      expect(
+        leaks,
+        `v3 chunk ${file} references v2 wire: ${leaks.join(', ')}`,
+      ).toEqual([])
+    }
+  })
+
   it('control vs middleware chunk graphs are disjoint (modulo shared constants chunk)', () => {
     const controlChunks = new Set(collectGraph('control.js').keys())
     const middlewareChunks = new Set(collectGraph('middleware.js').keys())
diff --git a/packages/prisma-next/test/live/bigint-live-pg.test.ts b/packages/prisma-next/test/live/bigint-live-pg.test.ts
new file mode 100644
index 00000000..71454c94
--- /dev/null
+++ b/packages/prisma-next/test/live/bigint-live-pg.test.ts
@@ -0,0 +1,179 @@
+/**
+ * Live-PG bigint family: `public.eql_v3_bigint` (storage-only),
+ * `eql_v3_bigint_eq` (equality), `eql_v3_bigint_ord` (equality +
+ * order/range). Proves a JS `bigint` plaintext survives losslessly —
+ * including a value ABOVE `Number.MAX_SAFE_INTEGER`, which a
+ * number-typed pipeline would corrupt — and that the encrypted
+ * ordering terms order the real domain correctly.
+ */
+
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedBigInt } from '../../src/execution/envelope-bigint'
+import { cipherstashV3Asc } from '../../src/v3/operators-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../v3/operator-lowering-v3.helpers'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  BIGINT_EQ,
+  BIGINT_ORD,
+  BIGINT_STORAGE,
+  createLiveTable,
+  decryptCell,
+  insertEncryptedRows,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  runLoweredSelect,
+  selectCell,
+  selectIdsOrderBy,
+  selectIdsWhere,
+  setupLiveV3,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const TABLE = 'pn_v3_live_bigint'
+const COLUMNS = {
+  balance: BIGINT_STORAGE,
+  balance_eq: BIGINT_EQ,
+  balance_ord: BIGINT_ORD,
+} as const
+const contract = liveV3Contract(TABLE, COLUMNS)
+
+// 2^53 + 1: NOT representable as a JS number. Losslessness here proves
+// the pipeline is bigint end-to-end (protect-ffi's eqlVersion-3 int8).
+const UNSAFE_BIG = 9_007_199_254_740_993n
+
+const SEED = [
+  { id: 'small', value: 42n },
+  { id: 'negative', value: -7n },
+  { id: 'huge', value: UNSAFE_BIG },
+] as const
+
+describeLivePg('v3 bigint domains against live Postgres', () => {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+    await createLiveTable(sql, TABLE, COLUMNS)
+    live = await setupLiveV3(contract)
+    await insertEncryptedRows(
+      sql,
+      live.middleware,
+      TABLE,
+      SEED.map((row) => ({
+        id: row.id,
+        cells: {
+          balance: {
+            codecId: BIGINT_STORAGE,
+            value: EncryptedBigInt.from(row.value),
+          },
+          balance_eq: {
+            codecId: BIGINT_EQ,
+            value: EncryptedBigInt.from(row.value),
+          },
+          balance_ord: {
+            codecId: BIGINT_ORD,
+            value: EncryptedBigInt.from(row.value),
+          },
+        },
+      })),
+    )
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('decrypts to a JS bigint, losslessly, beyond Number.MAX_SAFE_INTEGER', async () => {
+    for (const column of ['balance', 'balance_eq', 'balance_ord'] as const) {
+      const decrypted = await decryptCell(live.sdk, EncryptedBigInt, {
+        cell: await selectCell(sql, TABLE, column, 'huge'),
+        table: TABLE,
+        column,
+      })
+      expect(typeof decrypted, `${column} must decrypt to bigint`).toBe(
+        'bigint',
+      )
+      expect(decrypted).toBe(UNSAFE_BIG)
+    }
+
+    const negative = await decryptCell(live.sdk, EncryptedBigInt, {
+      cell: await selectCell(sql, TABLE, 'balance', 'negative'),
+      table: TABLE,
+      column: 'balance',
+    })
+    expect(negative).toBe(-7n)
+  }, 60_000)
+
+  it('cipherstashEq on bigint_eq selects exactly the matching row', async () => {
+    const result = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsWhere(
+        TABLE,
+        callOperator(
+          getOperator('cipherstashEq'),
+          columnAccessorV3(TABLE, 'balance_eq', BIGINT_EQ),
+          UNSAFE_BIG,
+        ),
+      ),
+    )
+    expect(result.sql).toContain('::eql_v3.query_bigint_eq')
+    expect(result.ids).toEqual(['huge'])
+  }, 60_000)
+
+  it('range predicates on bigint_ord respect numeric order across the huge value', async () => {
+    const ord = () => columnAccessorV3(TABLE, 'balance_ord', BIGINT_ORD)
+    const gt = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsWhere(
+        TABLE,
+        callOperator(getOperator('cipherstashGt'), ord(), 42n),
+      ),
+    )
+    expect(gt.ids).toEqual(['huge'])
+
+    const between = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsWhere(
+        TABLE,
+        callOperator(getOperator('cipherstashBetween'), ord(), -100n, 100n),
+      ),
+    )
+    expect(between.ids.sort()).toEqual(['negative', 'small'])
+  }, 60_000)
+
+  it('orders by the encrypted order term in numeric order', async () => {
+    const asc = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsOrderBy(TABLE, [
+        cipherstashV3Asc(columnAccessorV3(TABLE, 'balance_ord', BIGINT_ORD)),
+      ]),
+    )
+    expect(asc.sql).toContain('eql_v3.ord_term')
+    expect(asc.ids).toEqual(['negative', 'small', 'huge'])
+  }, 60_000)
+
+  it('the storage-only bigint domain refuses search operators', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'balance', BIGINT_STORAGE),
+        42n,
+      ),
+    ).toThrow(/equality/)
+  })
+})
diff --git a/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts b/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
new file mode 100644
index 00000000..d647497c
--- /dev/null
+++ b/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
@@ -0,0 +1,104 @@
+/**
+ * Live-PG boolean storage: `public.eql_v3_boolean` is STORAGE-ONLY
+ * (no indexes, all query capabilities false). Values survive
+ * INSERT/SELECT/decrypt through the real client, and every search
+ * operator refuses the column with `EncryptionOperatorError` — there
+ * is no searchable term to mint.
+ */
+
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedBoolean } from '../../src/execution/envelope-boolean'
+import { EncryptionOperatorError } from '../../src/v3/query-term'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../v3/operator-lowering-v3.helpers'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  BOOLEAN,
+  createLiveTable,
+  decryptCell,
+  insertEncryptedRows,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  selectCell,
+  setupLiveV3,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const TABLE = 'pn_v3_live_boolean'
+const COLUMNS = { active: BOOLEAN } as const
+const contract = liveV3Contract(TABLE, COLUMNS)
+
+describeLivePg('v3 boolean storage against live Postgres', () => {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+    await createLiveTable(sql, TABLE, COLUMNS)
+    live = await setupLiveV3(contract)
+    await insertEncryptedRows(sql, live.middleware, TABLE, [
+      {
+        id: 'on',
+        cells: {
+          active: { codecId: BOOLEAN, value: EncryptedBoolean.from(true) },
+        },
+      },
+      {
+        id: 'off',
+        cells: {
+          active: { codecId: BOOLEAN, value: EncryptedBoolean.from(false) },
+        },
+      },
+    ])
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('true and false survive INSERT/SELECT/decrypt', async () => {
+    const on = await decryptCell(live.sdk, EncryptedBoolean, {
+      cell: await selectCell(sql, TABLE, 'active', 'on'),
+      table: TABLE,
+      column: 'active',
+    })
+    const off = await decryptCell(live.sdk, EncryptedBoolean, {
+      cell: await selectCell(sql, TABLE, 'active', 'off'),
+      table: TABLE,
+      column: 'active',
+    })
+    expect(on).toBe(true)
+    expect(off).toBe(false)
+  }, 60_000)
+
+  it('every search operator throws EncryptionOperatorError on the storage-only domain', () => {
+    const active = () => columnAccessorV3(TABLE, 'active', BOOLEAN)
+    const attempts: ReadonlyArray<readonly [string, unknown[]]> = [
+      ['cipherstashEq', [true]],
+      ['cipherstashNe', [true]],
+      ['cipherstashInArray', [[true, false]]],
+      ['cipherstashNotInArray', [[true]]],
+      ['cipherstashGt', [false]],
+      ['cipherstashGte', [false]],
+      ['cipherstashLt', [true]],
+      ['cipherstashLte', [true]],
+      ['cipherstashBetween', [false, true]],
+      ['cipherstashNotBetween', [false, true]],
+      ['cipherstashIlike', ['tru']],
+      ['cipherstashNotIlike', ['tru']],
+      ['cipherstashJsonContains', [{ a: 1 }]],
+    ]
+    for (const [method, args] of attempts) {
+      expect(
+        () => callOperator(getOperator(method), active(), ...args),
+        `${method} must refuse eql_v3_boolean`,
+      ).toThrow(EncryptionOperatorError)
+    }
+  })
+})
diff --git a/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts b/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
new file mode 100644
index 00000000..6aada625
--- /dev/null
+++ b/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
@@ -0,0 +1,109 @@
+/**
+ * Live-PG bulk-encrypt middleware: the REAL `bulkEncryptMiddlewareV3`
+ * instance wired by `cipherstashFromStackV3` (real `EncryptionV3`
+ * client, not a fake) drives a multi-row INSERT. Proves end-to-end:
+ * the AST walk stamps `(table, column)` routing keys, the per-column
+ * batch makes ONE bulkEncrypt crossing, the param slots are replaced
+ * with plain JSONB text the pg driver serialises, the stored cells
+ * parse as JSON documents (never the v2 `("...")` composite literal),
+ * and every cell decrypts back to its original plaintext.
+ */
+
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { v3FromDriver } from '../../src/v3/wire-v3'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  createLiveTable,
+  decryptCell,
+  domainFor,
+  insertEncryptedRows,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  setupLiveV3,
+  TEXT_SEARCH,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const TABLE = 'pn_v3_live_bulk'
+const COLUMNS = { email: TEXT_SEARCH } as const
+const contract = liveV3Contract(TABLE, COLUMNS)
+
+const EMAILS = [
+  'bulk-0@example.com',
+  'bulk-1@example.com',
+  'bulk-2@example.com',
+] as const
+
+describeLivePg('v3 bulk-encrypt middleware against live Postgres', () => {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+  const envelopes = EMAILS.map((email) => EncryptedString.from(email))
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+    await createLiveTable(sql, TABLE, COLUMNS)
+    live = await setupLiveV3(contract)
+    await insertEncryptedRows(
+      sql,
+      live.middleware,
+      TABLE,
+      EMAILS.map((_, i) => ({
+        id: `row-${i}`,
+        cells: { email: { codecId: TEXT_SEARCH, value: envelopes[i] } },
+      })),
+    )
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('stores each cell as a JSON document in the v3 domain (plain JSONB wire)', async () => {
+    const rows = (await sql.unsafe(
+      `SELECT id, email, pg_typeof(email)::text AS domain FROM "${TABLE}" ORDER BY id`,
+    )) as unknown as Array<{ id: string; email: unknown; domain: string }>
+    expect(rows).toHaveLength(EMAILS.length)
+    for (const row of rows) {
+      expect(`public.${row.domain}`).toBe(domainFor(TEXT_SEARCH))
+      // The cell parses as a JSON document — the v3 wire. A v2 composite
+      // literal ('("...")') would fail this parse/shape check.
+      const payload = v3FromDriver<unknown>(row.email as string | object)
+      expect(payload).toBeTypeOf('object')
+      expect(payload).not.toBeNull()
+      expect(Array.isArray(payload)).toBe(false)
+    }
+  }, 60_000)
+
+  it('stamps the storage ciphertext back onto the write envelopes (plaintext retained)', () => {
+    for (const [i, envelope] of envelopes.entries()) {
+      const handle = envelope.expose()
+      expect(
+        handle.ciphertext,
+        'write envelope must carry the minted ciphertext',
+      ).toBeDefined()
+      expect(handle.plaintext).toBe(EMAILS[i])
+      expect(handle.table).toBe(TABLE)
+      expect(handle.column).toBe('email')
+    }
+  })
+
+  it('every stored cell decrypts back to its original plaintext through the real client', async () => {
+    const rows = (await sql.unsafe(
+      `SELECT id, email FROM "${TABLE}" ORDER BY id`,
+    )) as unknown as Array<{ id: string; email: unknown }>
+    const decrypted = await Promise.all(
+      rows.map((row) =>
+        decryptCell(live.sdk, EncryptedString, {
+          cell: row.email,
+          table: TABLE,
+          column: 'email',
+        }),
+      ),
+    )
+    expect(decrypted).toEqual([...EMAILS])
+  }, 60_000)
+})
diff --git a/packages/prisma-next/test/live/helpers/eql-v3.ts b/packages/prisma-next/test/live/helpers/eql-v3.ts
new file mode 100644
index 00000000..6cd3eb98
--- /dev/null
+++ b/packages/prisma-next/test/live/helpers/eql-v3.ts
@@ -0,0 +1,62 @@
+/**
+ * Idempotent, concurrency-safe EQL v3 install for the live suites.
+ *
+ * The install SQL comes from `src/migration/eql-bundle-v3.ts` — the
+ * SAME `@cipherstash/eql/sql` `readInstallSql()` source the shipped v3
+ * baseline migration bakes into its `ops.json` — so installing here
+ * exercises the exact bytes a customer's migration applies (the
+ * `migration-apply-live-pg` suite pins that byte-identity).
+ *
+ * Mirrors the stack's historical `installEqlV3IfNeeded` helper: a
+ * session advisory lock serialises concurrent vitest workers (every
+ * live suite installs in its `beforeAll`), and `eql_v3.version()` is
+ * the staleness probe — reinstall only when the installed version
+ * differs from the pinned release manifest.
+ */
+
+import type postgres from 'postgres'
+import {
+  readInstallSql,
+  releaseManifest,
+} from '../../../src/migration/eql-bundle-v3'
+
+const EQL_V3_ADVISORY_LOCK_ID = 3_733_003
+
+async function readEqlV3Version(
+  sql: postgres.Sql | postgres.ReservedSql,
+): Promise<string | null> {
+  const [probe] = await sql<
+    { present: boolean }[]
+  >`SELECT to_regprocedure('eql_v3.version()') IS NOT NULL AS present`
+  if (!probe?.present) return null
+  const [row] = await sql<
+    { version: string }[]
+  >`SELECT eql_v3.version() AS version`
+  return row?.version ?? null
+}
+
+export async function installEqlV3IfNeeded(sql: postgres.Sql): Promise<void> {
+  // Advisory locks are session-scoped: reserve one physical connection
+  // so lock and unlock land on the same session even though `postgres`
+  // pools.
+  const reserved = await sql.reserve()
+  try {
+    await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})`
+    try {
+      if ((await readEqlV3Version(reserved)) === releaseManifest.eqlVersion) {
+        return
+      }
+      await reserved.unsafe(readInstallSql())
+      const installed = await readEqlV3Version(reserved)
+      if (installed !== releaseManifest.eqlVersion) {
+        throw new Error(
+          `EQL v3 installation did not yield ${releaseManifest.eqlVersion}, got ${installed ?? 'none'}`,
+        )
+      }
+    } finally {
+      await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})`
+    }
+  } finally {
+    reserved.release()
+  }
+}
diff --git a/packages/prisma-next/test/live/helpers/harness.ts b/packages/prisma-next/test/live/helpers/harness.ts
new file mode 100644
index 00000000..8a297222
--- /dev/null
+++ b/packages/prisma-next/test/live/helpers/harness.ts
@@ -0,0 +1,357 @@
+/**
+ * Shared scaffolding for the live-PG EQL v3 suites.
+ *
+ * Everything on the encryption path is REAL:
+ *
+ *   - the client is `cipherstashFromStackV3({ contractJson })` over a
+ *     real `EncryptionV3` (ZeroKMS round-trips, no fakes);
+ *   - writes go through the REAL v3 bulk-encrypt middleware returned by
+ *     that factory (`cs.middleware[0].beforeExecute`), driven exactly
+ *     the way the SQL runtime drives it: an execution plan whose AST
+ *     carries the `ParamRef`s, plus `createSqlParamRefMutator(plan)`;
+ *   - reads decrypt through the same per-castAs envelope
+ *     `fromInternal(...).decrypt()` path the v3 cell codec's `decode`
+ *     uses, against a `createCipherstashV3Sdk` adapter over the same
+ *     client;
+ *   - operator SELECTs are lowered by the REAL postgres adapter from
+ *     the REAL v3 operator descriptors (`makeV3Adapter().lower`), so
+ *     the SQL that executes against Postgres is byte-for-byte the SQL
+ *     the product emits.
+ *
+ * Only the plumbing a full ORM client would add (driver wiring, model
+ * accessors) is inlined — same seams as the unit-level middleware and
+ * operator-lowering suites, now pointed at a real database.
+ */
+
+import type { PostgresContract } from '@prisma-next/adapter-postgres/types'
+import { validateSqlContractFully } from '@prisma-next/sql-contract/validators'
+import {
+  type AnyExpression,
+  ColumnRef,
+  InsertAst,
+  type OrderByItem,
+  ParamRef,
+  ProjectionItem,
+  SelectAst,
+  TableSource,
+} from '@prisma-next/sql-relational-core/ast'
+import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan'
+import type { SqlMiddleware } from '@prisma-next/sql-runtime'
+import postgres from 'postgres'
+import type { EncryptedEnvelopeBase } from '../../../src/execution/envelope-base'
+import type { CipherstashSdk } from '../../../src/execution/sdk'
+import {
+  type CipherstashFromStackV3Result,
+  cipherstashFromStackV3,
+} from '../../../src/stack/from-stack-v3'
+import {
+  toV3CodecId,
+  V3_DOMAIN_META_BY_CODEC_ID,
+} from '../../../src/v3/catalog'
+import { deriveStackSchemasV3 } from '../../../src/v3/derive-schemas-v3'
+import { createCipherstashV3Sdk } from '../../../src/v3/sdk-adapter-v3'
+import { v3FromDriver } from '../../../src/v3/wire-v3'
+import {
+  baseMeta,
+  createCtx,
+  createSqlParamRefMutator,
+} from '../../bulk-encrypt-middleware.helpers'
+import {
+  literalParamValue,
+  makeV3Adapter,
+} from '../../v3/operator-lowering-v3.helpers'
+import { liveDatabaseUrl } from './live-gate'
+
+// GA codec ids (registry key VERBATIM — never strip the `eql_v3_` prefix).
+export const TEXT_SEARCH = toV3CodecId('eql_v3_text_search')
+export const TEXT_EQ = toV3CodecId('eql_v3_text_eq')
+export const INTEGER_ORD = toV3CodecId('eql_v3_integer_ord')
+export const DATE_ORD = toV3CodecId('eql_v3_date_ord')
+export const TIMESTAMP_ORD = toV3CodecId('eql_v3_timestamp_ord')
+export const BOOLEAN = toV3CodecId('eql_v3_boolean')
+export const BIGINT_STORAGE = toV3CodecId('eql_v3_bigint')
+export const BIGINT_EQ = toV3CodecId('eql_v3_bigint_eq')
+export const BIGINT_ORD = toV3CodecId('eql_v3_bigint_ord')
+export const JSON_CODEC = toV3CodecId('eql_v3_json')
+
+const PG_TEXT = 'pg/text@1'
+
+/**
+ * A live connection with the settings every suite wants: no prepared
+ * statements (poolers), and `DROP TABLE IF EXISTS` notices silenced so
+ * the vitest output stays readable.
+ */
+export function liveConnection(): postgres.Sql {
+  return postgres(liveDatabaseUrl(), { prepare: false, onnotice: () => {} })
+}
+
+export function domainFor(codecId: string): string {
+  const meta = V3_DOMAIN_META_BY_CODEC_ID.get(codecId)
+  if (!meta) throw new Error(`live harness: unknown v3 codec id ${codecId}`)
+  return meta.nativeType
+}
+
+/**
+ * Build a validated contract for one live table: a plain-text `id`
+ * primary key plus one v3 column per `(name → codec id)` entry, each
+ * carrying its concrete `public.eql_v3_*` domain and the catalog's
+ * `{ castAs, capabilities }` typeParams block — the exact shape v3
+ * authoring emits.
+ */
+export function liveV3Contract(
+  tableName: string,
+  columns: Readonly<Record<string, string>>,
+): PostgresContract {
+  const columnEntries: Record<string, object> = {
+    id: { codecId: PG_TEXT, nativeType: 'text', nullable: false },
+  }
+  for (const [name, codecId] of Object.entries(columns)) {
+    const meta = V3_DOMAIN_META_BY_CODEC_ID.get(codecId)
+    if (!meta) throw new Error(`live harness: unknown v3 codec id ${codecId}`)
+    columnEntries[name] = {
+      codecId,
+      nativeType: meta.nativeType,
+      nullable: true,
+      typeParams: { castAs: meta.castAs, capabilities: meta.capabilities },
+    }
+  }
+  return validateSqlContractFully<PostgresContract>({
+    target: 'postgres',
+    targetFamily: 'sql',
+    profileHash: `sha256:cipherstash-live-${tableName}`,
+    roots: {},
+    capabilities: {},
+    extensionPacks: {},
+    meta: {},
+    storage: {
+      storageHash: `sha256:cipherstash-live-${tableName}-storage`,
+      namespaces: {
+        __unbound__: {
+          id: '__unbound__',
+          entries: {
+            table: {
+              [tableName]: {
+                columns: columnEntries,
+                uniques: [],
+                indexes: [],
+                foreignKeys: [],
+              },
+            },
+          },
+        },
+      },
+    },
+    domain: { namespaces: { __unbound__: { models: {} } } },
+  })
+}
+
+/** DROP + CREATE the live table matching a `liveV3Contract` fixture. */
+export async function createLiveTable(
+  sql: postgres.Sql,
+  tableName: string,
+  columns: Readonly<Record<string, string>>,
+): Promise<void> {
+  const defs = Object.entries(columns)
+    .map(([name, codecId]) => `"${name}" ${domainFor(codecId)}`)
+    .join(', ')
+  await sql.unsafe(`DROP TABLE IF EXISTS "${tableName}"`)
+  await sql.unsafe(
+    `CREATE TABLE "${tableName}" (id text PRIMARY KEY${defs ? `, ${defs}` : ''})`,
+  )
+}
+
+export interface LiveV3Client {
+  readonly cs: CipherstashFromStackV3Result
+  /** The REAL middleware instance wired by `cipherstashFromStackV3`. */
+  readonly middleware: SqlMiddleware
+  /** Read-side SDK adapter over the same client (envelope decrypt path). */
+  readonly sdk: CipherstashSdk
+}
+
+export async function setupLiveV3(
+  contract: PostgresContract,
+): Promise<LiveV3Client> {
+  const cs = await cipherstashFromStackV3({ contractJson: contract })
+  const middleware = cs.middleware[0]
+  if (!middleware) {
+    throw new Error('cipherstashFromStackV3 returned no middleware')
+  }
+  const sdk = createCipherstashV3Sdk(
+    cs.encryptionClient,
+    deriveStackSchemasV3(contract),
+  )
+  return { cs, middleware, sdk }
+}
+
+export interface LiveRowSpec {
+  readonly id: string
+  /** column name → { codecId, value } (value: plaintext envelope or null). */
+  readonly cells: Readonly<
+    Record<string, { readonly codecId: string; readonly value: unknown }>
+  >
+}
+
+/**
+ * INSERT rows through the REAL v3 bulk-encrypt middleware: build the
+ * `InsertAst` + hand-written INSERT statement with positionally-matching
+ * params, run `beforeExecute` (which stamps routing keys from the AST,
+ * batches per-column `bulkEncrypt`/`encryptQuery` crossings, and
+ * replaces envelope params with JSONB text), then execute against the
+ * live database.
+ */
+export async function insertEncryptedRows(
+  sql: postgres.Sql,
+  middleware: SqlMiddleware,
+  tableName: string,
+  rows: ReadonlyArray<LiveRowSpec>,
+): Promise<void> {
+  const first = rows[0]
+  if (!first) return
+  const columnNames = ['id', ...Object.keys(first.cells)]
+
+  const params: unknown[] = []
+  const astRows = rows.map((row) => {
+    const astRow: Record<string, ParamRef> = {}
+    const idRef = ParamRef.of(row.id, { codec: { codecId: PG_TEXT } })
+    astRow.id = idRef
+    params.push(row.id)
+    for (const [column, cell] of Object.entries(row.cells)) {
+      const ref = ParamRef.of(cell.value, {
+        codec: { codecId: cell.codecId },
+      })
+      astRow[column] = ref
+      params.push(cell.value)
+    }
+    return astRow
+  })
+
+  const placeholders = rows
+    .map(
+      (_, rowIndex) =>
+        `(${columnNames
+          .map(
+            (_c, colIndex) =>
+              `$${rowIndex * columnNames.length + colIndex + 1}`,
+          )
+          .join(', ')})`,
+    )
+    .join(', ')
+  const insertSql = `INSERT INTO "${tableName}" (${columnNames
+    .map((c) => `"${c}"`)
+    .join(', ')}) VALUES ${placeholders}`
+
+  const ast = new InsertAst(TableSource.named(tableName), astRows)
+  const plan = {
+    sql: insertSql,
+    params,
+    meta: { ...baseMeta },
+    ast,
+  } as SqlExecutionPlan
+
+  const mutator = createSqlParamRefMutator(plan)
+  await middleware.beforeExecute?.(plan, createCtx(), mutator)
+  // The middleware replaced every envelope param with plain JSONB text;
+  // what remains is driver-serialisable.
+  await sql.unsafe(insertSql, [...mutator.currentParams()] as never[])
+}
+
+/** `SELECT id FROM t WHERE <predicate>` as a SelectAst. */
+export function selectIdsWhere(
+  tableName: string,
+  predicate: AnyExpression,
+): SelectAst {
+  return SelectAst.from(TableSource.named(tableName))
+    .withProjection([ProjectionItem.of('id', ColumnRef.of(tableName, 'id'))])
+    .withWhere(predicate)
+}
+
+/** `SELECT id FROM t ORDER BY <items>` as a SelectAst. */
+export function selectIdsOrderBy(
+  tableName: string,
+  items: ReadonlyArray<OrderByItem>,
+): SelectAst {
+  return SelectAst.from(TableSource.named(tableName))
+    .withProjection([ProjectionItem.of('id', ColumnRef.of(tableName, 'id'))])
+    .withOrderBy(items)
+}
+
+export interface ExecutedSelect {
+  readonly sql: string
+  readonly ids: string[]
+}
+
+/**
+ * Lower a SelectAst through the real postgres adapter + v3 operator
+ * descriptors, run the lowered params through the REAL middleware (this
+ * is where operator query-term envelopes become ciphertext-free
+ * `encryptQuery` terms), execute the lowered SQL against the live
+ * database, and return the selected ids.
+ */
+export async function runLoweredSelect(
+  sql: postgres.Sql,
+  middleware: SqlMiddleware,
+  contract: PostgresContract,
+  ast: SelectAst,
+): Promise<ExecutedSelect> {
+  const lowered = makeV3Adapter().lower(ast, { contract })
+  const plan = {
+    sql: lowered.sql,
+    params: lowered.params.map(literalParamValue),
+    meta: { ...baseMeta },
+    ast,
+  } as SqlExecutionPlan
+  const mutator = createSqlParamRefMutator(plan)
+  await middleware.beforeExecute?.(plan, createCtx(), mutator)
+  const rows = (await sql.unsafe(lowered.sql, [
+    ...mutator.currentParams(),
+  ] as never[])) as unknown as Array<{ id: string }>
+  return { sql: lowered.sql, ids: rows.map((row) => row.id) }
+}
+
+/**
+ * Read one encrypted cell straight off the table and decrypt it through
+ * the envelope path the v3 cell codec's `decode` uses.
+ */
+export async function selectCell(
+  sql: postgres.Sql,
+  tableName: string,
+  column: string,
+  id: string,
+): Promise<unknown> {
+  const rows = (await sql.unsafe(
+    `SELECT "${column}" AS cell FROM "${tableName}" WHERE id = $1`,
+    [id],
+  )) as unknown as Array<{ cell: unknown }>
+  if (rows.length !== 1) {
+    throw new Error(
+      `selectCell: expected exactly 1 row for ${tableName}.${column} id=${id}, got ${rows.length}`,
+    )
+  }
+  return rows[0]?.cell
+}
+
+export async function decryptCell<T>(
+  sdk: CipherstashSdk,
+  envelope: {
+    fromInternal(args: {
+      ciphertext: unknown
+      table: string
+      column: string
+      sdk: CipherstashSdk
+    }): EncryptedEnvelopeBase<T>
+  },
+  args: {
+    readonly cell: unknown
+    readonly table: string
+    readonly column: string
+  },
+): Promise<T> {
+  return envelope
+    .fromInternal({
+      ciphertext: v3FromDriver(args.cell as string | object | null),
+      table: args.table,
+      column: args.column,
+      sdk,
+    })
+    .decrypt()
+}
diff --git a/packages/prisma-next/test/live/helpers/live-gate.ts b/packages/prisma-next/test/live/helpers/live-gate.ts
new file mode 100644
index 00000000..2a2ae28a
--- /dev/null
+++ b/packages/prisma-next/test/live/helpers/live-gate.ts
@@ -0,0 +1,58 @@
+/**
+ * Self-gating for the live-PG EQL v3 suites.
+ *
+ * The live suites need two things a hermetic CI job does not have:
+ *
+ *   1. **CipherStash credentials** for the real ZeroKMS round-trips —
+ *      either ALL FOUR `CS_*` variables in the environment, or (locally)
+ *      a `~/.cipherstash` device profile written by `stash auth login`,
+ *      which protect-ffi's `AutoStrategy` picks up with no environment
+ *      at all. A PARTIAL `CS_*` environment counts as neither: it would
+ *      fail deep inside the client with "[encryption]: Not
+ *      authenticated", which names nothing — mirroring the rejection
+ *      rationale in `packages/test-kit/src/env.ts`.
+ *   2. **A Postgres to talk to** — `DATABASE_URL`. Locally:
+ *
+ *        docker compose -f local/docker-compose.postgres.yml up -d --wait
+ *        export DATABASE_URL=postgres://cipherstash:password@localhost:55432/cipherstash
+ *
+ * When either is missing the suites SKIP (describe.skip) so the default
+ * `pnpm test` run stays green on machines without secrets — the posture
+ * the plan chose for this package (unlike `packages/stack/integration`,
+ * whose suites run under a separate config and throw instead).
+ */
+
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { describe } from 'vitest'
+
+const CS_VARS = [
+  'CS_WORKSPACE_CRN',
+  'CS_CLIENT_ID',
+  'CS_CLIENT_KEY',
+  'CS_CLIENT_ACCESS_KEY',
+] as const
+
+const missing = CS_VARS.filter((name) => !process.env[name])
+const hasProfile = existsSync(join(homedir(), '.cipherstash'))
+
+export const LIVE_CIPHERSTASH_ENABLED =
+  missing.length === 0 || (missing.length === CS_VARS.length && hasProfile)
+
+export const LIVE_EQL_V3_PG_ENABLED = Boolean(
+  process.env.DATABASE_URL && LIVE_CIPHERSTASH_ENABLED,
+)
+
+export const describeLivePg = LIVE_EQL_V3_PG_ENABLED ? describe : describe.skip
+
+/** The database URL, once the gate has established it exists. */
+export function liveDatabaseUrl(): string {
+  const url = process.env.DATABASE_URL
+  if (!url) {
+    throw new Error(
+      'liveDatabaseUrl() called while the live gate is closed — guard the suite with describeLivePg.',
+    )
+  }
+  return url
+}
diff --git a/packages/prisma-next/test/live/migration-apply-live-pg.test.ts b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
new file mode 100644
index 00000000..8f9b799d
--- /dev/null
+++ b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
@@ -0,0 +1,129 @@
+/**
+ * Live-PG apply of the v3 baseline migration bundle.
+ *
+ * `installEqlV3IfNeeded` applies `readInstallSql()` — and this suite
+ * pins that those are byte-for-byte the SQL baked into the shipped
+ * migration's `ops.json` (`migrations/20260601T0100_install_eql_v3_bundle`),
+ * so a green run here IS a green apply of the customer-facing
+ * migration op. After install it verifies the observable contract: the
+ * `public.eql_v3_*` storage domains and the `eql_v3` operator schema
+ * exist, the op carries the `cipherstash:install-eql-v3-bundle-v1`
+ * invariant, the op's own postchecks hold against the live database,
+ * and no v2-style `add_search_config` was executed (v3 needs no
+ * per-column search configuration).
+ */
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'pathe'
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { CIPHERSTASH_V3_INVARIANTS } from '../../src/extension-metadata/constants-v3'
+import {
+  readInstallSql,
+  releaseManifest,
+} from '../../src/migration/eql-bundle-v3'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import { liveConnection } from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const MIGRATION_DIR = join(
+  dirname(dirname(dirname(fileURLToPath(import.meta.url)))),
+  'migrations',
+  '20260601T0100_install_eql_v3_bundle',
+)
+
+interface MigrationOp {
+  readonly id: string
+  readonly invariantId: string
+  readonly operationClass: string
+  readonly execute: ReadonlyArray<{
+    readonly description: string
+    readonly sql: string
+  }>
+  readonly postcheck: ReadonlyArray<{
+    readonly description: string
+    readonly sql: string
+  }>
+}
+
+function readOpsFixture(): MigrationOp {
+  const ops = JSON.parse(
+    readFileSync(join(MIGRATION_DIR, 'ops.json'), 'utf8'),
+  ) as MigrationOp[]
+  const op = ops[0]
+  if (ops.length !== 1 || !op) {
+    throw new Error(
+      `expected exactly one op in the v3 baseline migration, got ${ops.length}`,
+    )
+  }
+  return op
+}
+
+describeLivePg('v3 baseline migration bundle against live Postgres', () => {
+  let sql: postgres.Sql
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('the applied SQL is byte-for-byte the shipped migration op, carrying the v3 invariant', () => {
+    const op = readOpsFixture()
+    expect(op.id).toBe('cipherstash.install-eql-v3-bundle')
+    expect(op.invariantId).toBe(CIPHERSTASH_V3_INVARIANTS.installBundle)
+    expect(op.operationClass).toBe('additive')
+    expect(op.execute).toHaveLength(1)
+    // Byte identity: what installEqlV3IfNeeded just applied IS the
+    // migration bundle a customer's `prisma-next migrate` applies.
+    expect(op.execute[0]?.sql).toBe(readInstallSql())
+  })
+
+  it('installs the pinned release: eql_v3.version() matches the manifest', async () => {
+    const [row] = await sql<{ version: string }[]>`
+      SELECT eql_v3.version() AS version
+    `
+    expect(row?.version).toBe(releaseManifest.eqlVersion)
+  }, 60_000)
+
+  it('creates the public.eql_v3_* storage domains and the eql_v3 operator schema', async () => {
+    const [types] = await sql<
+      { text_search: string | null; integer_ord: string | null }[]
+    >`
+      SELECT
+        to_regtype('public.eql_v3_text_search')::text AS text_search,
+        to_regtype('public.eql_v3_integer_ord')::text AS integer_ord
+    `
+    expect(types?.text_search).not.toBeNull()
+    expect(types?.integer_ord).not.toBeNull()
+
+    const [schema] = await sql<{ present: boolean }[]>`
+      SELECT EXISTS (
+        SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3'
+      ) AS present
+    `
+    expect(schema?.present).toBe(true)
+  }, 60_000)
+
+  it("the migration op's own postchecks hold against the live database", async () => {
+    const op = readOpsFixture()
+    expect(op.postcheck.length).toBeGreaterThan(0)
+    for (const check of op.postcheck) {
+      const rows = (await sql.unsafe(check.sql)) as unknown as Array<
+        Record<string, unknown>
+      >
+      const value = Object.values(rows[0] ?? {})[0]
+      expect(value, check.description).toBe(true)
+    }
+  }, 60_000)
+
+  it('executes no v2-style search configuration (no add_search_config)', () => {
+    const bundle = readInstallSql()
+    expect(bundle).not.toContain('add_search_config')
+    expect(bundle).not.toContain('remove_search_config')
+  })
+})
diff --git a/packages/prisma-next/test/live/operators-live-pg.test.ts b/packages/prisma-next/test/live/operators-live-pg.test.ts
new file mode 100644
index 00000000..2ef5ae7a
--- /dev/null
+++ b/packages/prisma-next/test/live/operators-live-pg.test.ts
@@ -0,0 +1,307 @@
+/**
+ * Live-PG v3 operator round-trips, one capability tier per describe:
+ * encrypt → INSERT (real middleware) → operator SELECT (real lowered
+ * `eql_v3.*` SQL, real `encryptQuery` terms) → assert the EXPECTED ROWS
+ * are selected → decrypt the stored cells back to the original
+ * plaintext. Includes the ruled-decision-2 JSON containment case
+ * (`@>` with `eql_v3.query_jsonb`).
+ */
+
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedDate } from '../../src/execution/envelope-date'
+import { EncryptedJson } from '../../src/execution/envelope-json'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { EncryptedNumber } from '../../src/v3/envelope-number'
+import { cipherstashV3Asc, cipherstashV3Desc } from '../../src/v3/operators-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../v3/operator-lowering-v3.helpers'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  createLiveTable,
+  DATE_ORD,
+  decryptCell,
+  INTEGER_ORD,
+  insertEncryptedRows,
+  JSON_CODEC,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  runLoweredSelect,
+  selectCell,
+  selectIdsOrderBy,
+  selectIdsWhere,
+  setupLiveV3,
+  TEXT_EQ,
+  TEXT_SEARCH,
+  TIMESTAMP_ORD,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const TABLE = 'pn_v3_live_operators'
+const COLUMNS = {
+  email: TEXT_SEARCH,
+  nickname: TEXT_EQ,
+  score: INTEGER_ORD,
+  birthday: DATE_ORD,
+  seen_at: TIMESTAMP_ORD,
+  payload: JSON_CODEC,
+} as const
+
+const contract = liveV3Contract(TABLE, COLUMNS)
+
+const SEED = [
+  {
+    id: 'ada',
+    email: 'ada@example.com',
+    nickname: 'ada',
+    score: 10,
+    birthday: new Date('1990-01-15T00:00:00Z'),
+    seenAt: new Date('2024-01-01T10:00:00Z'),
+    payload: { role: 'admin', tags: ['pioneer'] },
+  },
+  {
+    id: 'grace',
+    email: 'grace@example.com',
+    nickname: 'grace',
+    score: 25,
+    birthday: new Date('1985-06-30T00:00:00Z'),
+    seenAt: new Date('2024-06-15T12:30:00Z'),
+    payload: { role: 'user', tags: ['compiler'] },
+  },
+  {
+    id: 'zora',
+    email: 'zora@example.org',
+    nickname: 'zora',
+    score: 40,
+    birthday: new Date('2001-12-05T00:00:00Z'),
+    seenAt: new Date('2025-02-20T08:45:00Z'),
+    payload: { role: 'admin', level: 3 },
+  },
+] as const
+
+describeLivePg('v3 operators against live Postgres', () => {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+    await createLiveTable(sql, TABLE, COLUMNS)
+    live = await setupLiveV3(contract)
+    await insertEncryptedRows(
+      sql,
+      live.middleware,
+      TABLE,
+      SEED.map((row) => ({
+        id: row.id,
+        cells: {
+          email: {
+            codecId: TEXT_SEARCH,
+            value: EncryptedString.from(row.email),
+          },
+          nickname: {
+            codecId: TEXT_EQ,
+            value: EncryptedString.from(row.nickname),
+          },
+          score: {
+            codecId: INTEGER_ORD,
+            value: EncryptedNumber.from(row.score),
+          },
+          birthday: {
+            codecId: DATE_ORD,
+            value: EncryptedDate.from(row.birthday),
+          },
+          seen_at: {
+            codecId: TIMESTAMP_ORD,
+            value: EncryptedDate.from(row.seenAt),
+          },
+          payload: {
+            codecId: JSON_CODEC,
+            value: EncryptedJson.from(row.payload),
+          },
+        },
+      })),
+    )
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  const where = (predicate: ReturnType<typeof callOperator>) =>
+    runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsWhere(TABLE, predicate),
+    )
+
+  it('cipherstashEq on a text_search column selects exactly the matching row', async () => {
+    const result = await where(
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
+        'grace@example.com',
+      ),
+    )
+    expect(result.sql).toContain('eql_v3.eq')
+    expect(result.sql).toContain('::eql_v3.query_text_search')
+    expect(result.ids).toEqual(['grace'])
+  }, 60_000)
+
+  it('cipherstashEq / cipherstashNe / cipherstashInArray on a text_eq column', async () => {
+    const nickname = () => columnAccessorV3(TABLE, 'nickname', TEXT_EQ)
+    const eq = await where(
+      callOperator(getOperator('cipherstashEq'), nickname(), 'ada'),
+    )
+    expect(eq.ids).toEqual(['ada'])
+
+    const ne = await where(
+      callOperator(getOperator('cipherstashNe'), nickname(), 'ada'),
+    )
+    expect(ne.ids.sort()).toEqual(['grace', 'zora'])
+
+    const inArray = await where(
+      callOperator(getOperator('cipherstashInArray'), nickname(), [
+        'ada',
+        'zora',
+      ]),
+    )
+    expect(inArray.ids.sort()).toEqual(['ada', 'zora'])
+  }, 60_000)
+
+  it('cipherstashIlike lowers to eql_v3.contains and finds the token match', async () => {
+    const result = await where(
+      callOperator(
+        getOperator('cipherstashIlike'),
+        columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
+        'grace',
+      ),
+    )
+    expect(result.sql).toContain('eql_v3.contains')
+    expect(result.ids).toEqual(['grace'])
+  }, 60_000)
+
+  it('cipherstashGt / cipherstashLte / cipherstashBetween on integer_ord select the right rows', async () => {
+    const score = () => columnAccessorV3(TABLE, 'score', INTEGER_ORD)
+    const gt = await where(
+      callOperator(getOperator('cipherstashGt'), score(), 25),
+    )
+    expect(gt.ids).toEqual(['zora'])
+
+    const lte = await where(
+      callOperator(getOperator('cipherstashLte'), score(), 25),
+    )
+    expect(lte.ids.sort()).toEqual(['ada', 'grace'])
+
+    const between = await where(
+      callOperator(getOperator('cipherstashBetween'), score(), 11, 40),
+    )
+    expect(between.ids.sort()).toEqual(['grace', 'zora'])
+  }, 60_000)
+
+  it('cipherstashGt on date_ord and cipherstashBetween on timestamp_ord', async () => {
+    const bornAfter = await where(
+      callOperator(
+        getOperator('cipherstashGt'),
+        columnAccessorV3(TABLE, 'birthday', DATE_ORD),
+        new Date('1990-01-01T00:00:00Z'),
+      ),
+    )
+    expect(bornAfter.ids.sort()).toEqual(['ada', 'zora'])
+
+    const seenIn2024 = await where(
+      callOperator(
+        getOperator('cipherstashBetween'),
+        columnAccessorV3(TABLE, 'seen_at', TIMESTAMP_ORD),
+        new Date('2024-01-01T00:00:00Z'),
+        new Date('2024-12-31T23:59:59Z'),
+      ),
+    )
+    expect(seenIn2024.ids.sort()).toEqual(['ada', 'grace'])
+  }, 60_000)
+
+  it('cipherstashV3Asc / Desc order by the encrypted order term', async () => {
+    const score = () => columnAccessorV3(TABLE, 'score', INTEGER_ORD)
+    const asc = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsOrderBy(TABLE, [cipherstashV3Asc(score())]),
+    )
+    expect(asc.sql).toContain('eql_v3.ord_term')
+    expect(asc.ids).toEqual(['ada', 'grace', 'zora'])
+
+    const desc = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsOrderBy(TABLE, [cipherstashV3Desc(score())]),
+    )
+    expect(desc.ids).toEqual(['zora', 'grace', 'ada'])
+  }, 60_000)
+
+  it('cipherstashJsonContains (@> with eql_v3.query_jsonb) selects by encrypted containment', async () => {
+    const result = await where(
+      callOperator(
+        getOperator('cipherstashJsonContains'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC),
+        { role: 'admin' },
+      ),
+    )
+    expect(result.sql).toContain('OPERATOR(public.@>)')
+    expect(result.sql).toContain('::eql_v3.query_jsonb')
+    expect(result.ids.sort()).toEqual(['ada', 'zora'])
+
+    const nested = await where(
+      callOperator(
+        getOperator('cipherstashJsonContains'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC),
+        { tags: ['compiler'] },
+      ),
+    )
+    expect(nested.ids).toEqual(['grace'])
+  }, 60_000)
+
+  it('every domain family decrypts back to the original plaintext', async () => {
+    const grace = SEED[1]
+    const email = await decryptCell(live.sdk, EncryptedString, {
+      cell: await selectCell(sql, TABLE, 'email', grace.id),
+      table: TABLE,
+      column: 'email',
+    })
+    expect(email).toBe(grace.email)
+
+    const score = await decryptCell(live.sdk, EncryptedNumber, {
+      cell: await selectCell(sql, TABLE, 'score', grace.id),
+      table: TABLE,
+      column: 'score',
+    })
+    expect(score).toBe(grace.score)
+
+    const birthday = await decryptCell(live.sdk, EncryptedDate, {
+      cell: await selectCell(sql, TABLE, 'birthday', grace.id),
+      table: TABLE,
+      column: 'birthday',
+    })
+    expect(birthday.toISOString().slice(0, 10)).toBe('1985-06-30')
+
+    const seenAt = await decryptCell(live.sdk, EncryptedDate, {
+      cell: await selectCell(sql, TABLE, 'seen_at', grace.id),
+      table: TABLE,
+      column: 'seen_at',
+    })
+    expect(seenAt.getTime()).toBe(grace.seenAt.getTime())
+
+    const payload = await decryptCell(live.sdk, EncryptedJson, {
+      cell: await selectCell(sql, TABLE, 'payload', grace.id),
+      table: TABLE,
+      column: 'payload',
+    })
+    expect(payload).toEqual(grace.payload)
+  }, 60_000)
+})
diff --git a/packages/prisma-next/test/live/operators-null-live-pg.test.ts b/packages/prisma-next/test/live/operators-null-live-pg.test.ts
new file mode 100644
index 00000000..d4de8338
--- /dev/null
+++ b/packages/prisma-next/test/live/operators-null-live-pg.test.ts
@@ -0,0 +1,115 @@
+/**
+ * Live-PG null handling: NULL cells pass through the real middleware
+ * untouched (no encrypt crossing is minted for them), store as SQL
+ * NULL in the `public.eql_v3_*` domain column, read back as NULL, and
+ * the operators reject null OPERANDS with the isNull() hint instead of
+ * minting a nonsense query term.
+ */
+
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import { v3FromDriver } from '../../src/v3/wire-v3'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../v3/operator-lowering-v3.helpers'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  createLiveTable,
+  INTEGER_ORD,
+  insertEncryptedRows,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  runLoweredSelect,
+  selectCell,
+  selectIdsWhere,
+  setupLiveV3,
+  TEXT_SEARCH,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const TABLE = 'pn_v3_live_nulls'
+const COLUMNS = { email: TEXT_SEARCH, score: INTEGER_ORD } as const
+const contract = liveV3Contract(TABLE, COLUMNS)
+
+describeLivePg('v3 null round-trips against live Postgres', () => {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+    await createLiveTable(sql, TABLE, COLUMNS)
+    live = await setupLiveV3(contract)
+    await insertEncryptedRows(sql, live.middleware, TABLE, [
+      {
+        id: 'nully',
+        cells: {
+          email: { codecId: TEXT_SEARCH, value: null },
+          score: { codecId: INTEGER_ORD, value: null },
+        },
+      },
+      {
+        id: 'filled',
+        cells: {
+          email: {
+            codecId: TEXT_SEARCH,
+            value: EncryptedString.from('filled@example.com'),
+          },
+          score: { codecId: INTEGER_ORD, value: null },
+        },
+      },
+    ])
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('NULL cells store as SQL NULL and read back as null through the v3 wire', async () => {
+    const emailCell = await selectCell(sql, TABLE, 'email', 'nully')
+    const scoreCell = await selectCell(sql, TABLE, 'score', 'nully')
+    expect(emailCell).toBeNull()
+    expect(scoreCell).toBeNull()
+    // The wire decode preserves null — this is the cell value the codec
+    // layer would surface for a NULL column.
+    expect(v3FromDriver(emailCell as null)).toBeNull()
+  }, 60_000)
+
+  it('a NULL column does not shadow non-null rows for operator queries', async () => {
+    const result = await runLoweredSelect(
+      sql,
+      live.middleware,
+      contract,
+      selectIdsWhere(
+        TABLE,
+        callOperator(
+          getOperator('cipherstashEq'),
+          columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
+          'filled@example.com',
+        ),
+      ),
+    )
+    expect(result.ids).toEqual(['filled'])
+  }, 60_000)
+
+  it('operators reject a null operand with the isNull() hint', () => {
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashEq'),
+        columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
+        null,
+      ),
+    ).toThrow(/isNull/)
+    expect(() =>
+      callOperator(
+        getOperator('cipherstashGt'),
+        columnAccessorV3(TABLE, 'score', INTEGER_ORD),
+        null,
+      ),
+    ).toThrow(/isNull/)
+  })
+})
diff --git a/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
new file mode 100644
index 00000000..b12220f5
--- /dev/null
+++ b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
@@ -0,0 +1,230 @@
+/**
+ * Live-PG v2/v3 coexistence: a v2 client (`cipherstashFromStack`, v2
+ * contract, `public.eql_v2_encrypted` composite wire) and a v3 client
+ * (`cipherstashFromStackV3`, v3 contract, plain-JSONB domain wire)
+ * running in the SAME process against the SAME database — each with
+ * its own table, registry, descriptor, and middleware. Decision 1b:
+ * the two generations never share a client; this suite proves the two
+ * entry points coexist side by side without cross-talk (a mixed
+ * v2+v3-columns client is unsupported and pinned as a hard error in
+ * `from-stack-divergence-v3.test.ts`).
+ *
+ * The v2 half needs EQL v2 installed (the `local/` docker image ships
+ * it preinstalled); it skips itself when `public.eql_v2_encrypted` is
+ * absent so the suite stays runnable against a v3-only database.
+ */
+
+import type { PostgresContract } from '@prisma-next/adapter-postgres/types'
+import { validateSqlContractFully } from '@prisma-next/sql-contract/validators'
+import type postgres from 'postgres'
+import { afterAll, beforeAll, expect, it } from 'vitest'
+import { EncryptedString } from '../../src/execution/envelope-string'
+import type { CipherstashSdk } from '../../src/execution/sdk'
+import {
+  CIPHERSTASH_SPACE_ID,
+  CIPHERSTASH_STRING_CODEC_ID,
+} from '../../src/extension-metadata/constants'
+import { CIPHERSTASH_V3_SPACE_ID } from '../../src/extension-metadata/constants-v3'
+import { deriveStackSchemas } from '../../src/stack/derive-schemas'
+import {
+  type CipherstashFromStackResult,
+  cipherstashFromStack,
+} from '../../src/stack/from-stack'
+import { createCipherstashSdk } from '../../src/stack/sdk-adapter'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../v3/operator-lowering-v3.helpers'
+import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import {
+  createLiveTable,
+  decryptCell,
+  insertEncryptedRows,
+  type LiveV3Client,
+  liveConnection,
+  liveV3Contract,
+  runLoweredSelect,
+  selectIdsWhere,
+  setupLiveV3,
+  TEXT_SEARCH,
+} from './helpers/harness'
+import { describeLivePg } from './helpers/live-gate'
+
+const V2_TABLE = 'pn_live_side_v2'
+const V3_TABLE = 'pn_live_side_v3'
+const EQL_V2_ENCRYPTED_TYPE = 'public.eql_v2_encrypted'
+
+const v2Contract = validateSqlContractFully<PostgresContract>({
+  target: 'postgres',
+  targetFamily: 'sql',
+  profileHash: 'sha256:cipherstash-live-side-by-side-v2',
+  roots: {},
+  capabilities: {},
+  extensionPacks: {},
+  meta: {},
+  storage: {
+    storageHash: 'sha256:cipherstash-live-side-by-side-v2-storage',
+    namespaces: {
+      __unbound__: {
+        id: '__unbound__',
+        entries: {
+          table: {
+            [V2_TABLE]: {
+              columns: {
+                id: {
+                  codecId: 'pg/text@1',
+                  nativeType: 'text',
+                  nullable: false,
+                },
+                email: {
+                  codecId: CIPHERSTASH_STRING_CODEC_ID,
+                  nativeType: EQL_V2_ENCRYPTED_TYPE,
+                  nullable: true,
+                },
+              },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [],
+            },
+          },
+        },
+      },
+    },
+  },
+  domain: { namespaces: { __unbound__: { models: {} } } },
+})
+
+const v3Contract = liveV3Contract(V3_TABLE, { email: TEXT_SEARCH })
+
+const V2_EMAIL = 'v2-resident@example.com'
+const V3_EMAIL = 'v3-resident@example.com'
+
+describeLivePg('v2 and v3 clients side by side against live Postgres', () => {
+  let sql: postgres.Sql
+  let hasEqlV2 = false
+  let v2: CipherstashFromStackResult | undefined
+  let v2Sdk: CipherstashSdk | undefined
+  let v3: LiveV3Client
+
+  beforeAll(async () => {
+    sql = liveConnection()
+    await installEqlV3IfNeeded(sql)
+
+    // v3 half — always available once the bundle is installed.
+    await createLiveTable(sql, V3_TABLE, { email: TEXT_SEARCH })
+    v3 = await setupLiveV3(v3Contract)
+    await insertEncryptedRows(sql, v3.middleware, V3_TABLE, [
+      {
+        id: 'v3-row',
+        cells: {
+          email: {
+            codecId: TEXT_SEARCH,
+            value: EncryptedString.from(V3_EMAIL),
+          },
+        },
+      },
+    ])
+
+    // v2 half — only when the database carries the EQL v2 composite type.
+    const [probe] = await sql<{ present: boolean }[]>`
+      SELECT to_regtype(${EQL_V2_ENCRYPTED_TYPE}) IS NOT NULL AS present
+    `
+    hasEqlV2 = probe?.present === true
+    if (!hasEqlV2) return
+
+    await sql.unsafe(`DROP TABLE IF EXISTS "${V2_TABLE}"`)
+    await sql.unsafe(
+      `CREATE TABLE "${V2_TABLE}" (id text PRIMARY KEY, email ${EQL_V2_ENCRYPTED_TYPE})`,
+    )
+    v2 = await cipherstashFromStack({ contractJson: v2Contract })
+    v2Sdk = createCipherstashSdk(
+      v2.encryptionClient,
+      deriveStackSchemas(v2Contract),
+    )
+    const v2Middleware = v2.middleware[0]
+    if (!v2Middleware)
+      throw new Error('cipherstashFromStack returned no middleware')
+    await insertEncryptedRows(sql, v2Middleware, V2_TABLE, [
+      {
+        id: 'v2-row',
+        cells: {
+          email: {
+            codecId: CIPHERSTASH_STRING_CODEC_ID,
+            value: EncryptedString.from(V2_EMAIL),
+          },
+        },
+      },
+    ])
+  }, 240_000)
+
+  afterAll(async () => {
+    if (sql) await sql.end()
+  })
+
+  it('the two runtime descriptors carry distinct extension identities', () => {
+    expect(v3.cs.extensions[0]?.id).toBe(CIPHERSTASH_V3_SPACE_ID)
+    if (v2) {
+      expect(v2.extensions[0]?.id).toBe(CIPHERSTASH_SPACE_ID)
+      expect(v2.extensions[0]?.id).not.toBe(v3.cs.extensions[0]?.id)
+    }
+  })
+
+  it('the v3 client round-trips and queries with the v2 client alive in-process', async () => {
+    const result = await runLoweredSelect(
+      sql,
+      v3.middleware,
+      v3Contract,
+      selectIdsWhere(
+        V3_TABLE,
+        callOperator(
+          getOperator('cipherstashEq'),
+          columnAccessorV3(V3_TABLE, 'email', TEXT_SEARCH),
+          V3_EMAIL,
+        ),
+      ),
+    )
+    expect(result.ids).toEqual(['v3-row'])
+
+    const rows = (await sql.unsafe(
+      `SELECT email FROM "${V3_TABLE}" WHERE id = 'v3-row'`,
+    )) as unknown as Array<{ email: unknown }>
+    const decrypted = await decryptCell(v3.sdk, EncryptedString, {
+      cell: rows[0]?.email,
+      table: V3_TABLE,
+      column: 'email',
+    })
+    expect(decrypted).toBe(V3_EMAIL)
+  }, 60_000)
+
+  it('the two wires are physically distinct: v2 composite literal vs v3 JSONB document', async (ctx) => {
+    if (!hasEqlV2) return ctx.skip()
+    const [v2Row] = (await sql.unsafe(
+      `SELECT email::text AS wire FROM "${V2_TABLE}" WHERE id = 'v2-row'`,
+    )) as unknown as Array<{ wire: string }>
+    expect(v2Row?.wire.startsWith('(')).toBe(true)
+
+    const [v3Row] = (await sql.unsafe(
+      `SELECT email::text AS wire FROM "${V3_TABLE}" WHERE id = 'v3-row'`,
+    )) as unknown as Array<{ wire: string }>
+    expect(v3Row?.wire.trimStart().startsWith('{')).toBe(true)
+  }, 60_000)
+
+  it('the v2 client round-trips through its own registry and wire', async (ctx) => {
+    if (!hasEqlV2 || !v2Sdk) return ctx.skip()
+    // `eql_v2_encrypted` is a composite `(data jsonb)`; project the
+    // jsonb field so the driver hands back the EQL payload document.
+    const [row] = (await sql.unsafe(
+      `SELECT (email).data AS payload FROM "${V2_TABLE}" WHERE id = 'v2-row'`,
+    )) as unknown as Array<{ payload: unknown }>
+    expect(row?.payload).toBeTypeOf('object')
+
+    const decrypted = await EncryptedString.fromInternal({
+      ciphertext: row?.payload,
+      table: V2_TABLE,
+      column: 'email',
+      sdk: v2Sdk,
+    }).decrypt()
+    expect(decrypted).toBe(V2_EMAIL)
+  }, 60_000)
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 154c570c..f01ba5c1 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -489,6 +489,9 @@ importers:
       pathe:
         specifier: ^2.0.3
         version: 2.0.3
+      postgres:
+        specifier: ^3.4.8
+        version: 3.4.9
       tsup:
         specifier: catalog:repo
         version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.22.1)(typescript@5.9.3)(yaml@2.9.0)

From 5391deedf62ee6db28c2ec0c517ea84c14b3792d Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 14:56:39 -0600
Subject: [PATCH 11/21] docs(prisma-next): changeset for EQL v3 per-domain
 authoring surface

Also a stack changeset for the new eql/v3 barrel exports, and the
AGENTS.md repository-layout line updated for the v2/v3 split.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/eql-v3-prisma-next.md                | 17 +++++++++++++++++
 .../eql-v3-stack-domain-registry-exports.md     |  9 +++++++++
 AGENTS.md                                       |  2 +-
 3 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/eql-v3-prisma-next.md
 create mode 100644 .changeset/eql-v3-stack-domain-registry-exports.md

diff --git a/.changeset/eql-v3-prisma-next.md b/.changeset/eql-v3-prisma-next.md
new file mode 100644
index 00000000..0afc8841
--- /dev/null
+++ b/.changeset/eql-v3-prisma-next.md
@@ -0,0 +1,17 @@
+---
+'@cipherstash/prisma-next': minor
+---
+
+**Breaking:** EQL v3 columns are now authored through **concrete per-domain constructors** — the constructor you choose *is* the capability set. The legacy boolean-option surface (`EncryptedString({ equality, freeTextSearch, orderAndRange })`) is not carried into v3.
+
+- New per-domain constructors, one per exposed `public.eql_v3_*` domain:
+  - Text: `EncryptedText` (storage), `EncryptedTextEq`, `EncryptedTextOrd` (eq + order/range), `EncryptedTextMatch` (free-text), `EncryptedTextSearch` (eq + free-text + order/range).
+  - Scalars (Integer, Smallint, BigInt, Numeric, Real, Double, Date, Timestamp): `Encrypted<Fam>` (storage), `Encrypted<Fam>Eq`, `Encrypted<Fam>Ord`.
+  - `EncryptedBoolean` — storage-only (`public.eql_v3_boolean`); there is no boolean equality constructor.
+  - `EncryptedJson` — searchable encrypted JSONB (`public.eql_v3_json`, `ste_vec`), queried with `cipherstashJsonContains` (`@>` containment).
+- **Impossible capability combinations have no constructor** (e.g. text equality + free-text without order/range) — they are unrepresentable, not runtime errors.
+- **BigInt is a first-class v3 family** (`EncryptedBigInt` / `EncryptedBigIntEq` / `EncryptedBigIntOrd`, JS `bigint` plaintext, backed by `public.eql_v3_bigint*`).
+- Use the `*V2` constructors (`EncryptedStringV2`, `EncryptedDoubleV2`, `EncryptedBigIntV2`, `EncryptedDateV2`, `EncryptedBooleanV2`, `EncryptedJsonV2`) to keep EQL v2 columns. A client is v2 or v3 — the two runtime descriptors are never co-registered.
+- New `@cipherstash/prisma-next/v3` entry point: `cipherstashFromStackV3({ contractJson })` builds the v3 runtime descriptor, bulk-encrypt middleware, and a stack `EncryptionV3` client from the emitted contract.
+- Query operators (`cipherstashEq`, `cipherstashGt`, `cipherstashBetween`, `cipherstashInArray`, …) lower to `eql_v3.*` functions with operands cast to the domain's query type (`$n::eql_v3.query_<domain>`); `cipherstashIlike` maps to `eql_v3.contains` (bloom-filter token containment, not SQL `LIKE`); ordering uses `eql_v3.ord_term` / `eql_v3.ord_term_ore` by the column's ordering flavour. The domains are `public.eql_v3_*`; the operator functions live in the `eql_v3` schema.
+- A new baseline migration `20260601T0100_install_eql_v3_bundle` (invariant `cipherstash:install-eql-v3-bundle-v1`) installs the `public.eql_v3_*` domains and `eql_v3.*` functions from the pinned `@cipherstash/eql` release. Regenerate contracts and run migrations after changing constructors.
diff --git a/.changeset/eql-v3-stack-domain-registry-exports.md b/.changeset/eql-v3-stack-domain-registry-exports.md
new file mode 100644
index 00000000..dfc68d03
--- /dev/null
+++ b/.changeset/eql-v3-stack-domain-registry-exports.md
@@ -0,0 +1,9 @@
+---
+'@cipherstash/stack': minor
+---
+
+Export `DOMAIN_REGISTRY`, `factoryForDomain`, `stripDomainSchema`, and the
+`V3ColumnFactory` type from `@cipherstash/stack/eql/v3`. These let integration
+adapters (e.g. `@cipherstash/prisma-next`) derive the full EQL v3 domain
+catalog — native types, capabilities, cast kinds, and indexes — from the stack
+instead of hand-maintaining a copy.
diff --git a/AGENTS.md b/AGENTS.md
index 0b0b4a02..c7733052 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -81,7 +81,7 @@ If these variables are missing, tests that require live encryption will fail or
 - `packages/cli`: The `stash` CLI — auth, init, encryption schema, and database setup (`stash eql install`). Has its own `AGENTS.md`.
 - `packages/wizard`: AI-powered encryption setup (`@cipherstash/wizard`)
 - `packages/migrate`: Plaintext-to-encrypted column migration (`@cipherstash/migrate`) — resumable backfill, per-column state
-- `packages/prisma-next`: Prisma Next integration (`@cipherstash/prisma-next`) — searchable field-level encryption for Postgres
+- `packages/prisma-next`: Prisma Next integration (`@cipherstash/prisma-next`) — searchable field-level encryption for Postgres. EQL v2 (`*V2` constructors, `cipherstashFromStack`) and EQL v3 (per-domain constructors, `./v3` entry with `cipherstashFromStackV3`)
 - `packages/stack-drizzle`: Drizzle ORM integration (`@cipherstash/stack-drizzle`), depends on `@cipherstash/stack` — EQL v2 (`.`) and EQL v3 (`./v3`). Split out of `@cipherstash/stack`.
 - `packages/stack-supabase`: Supabase integration (`@cipherstash/stack-supabase`), depends on `@cipherstash/stack` — `encryptedSupabase` (v2) and `encryptedSupabaseV3` (v3). Split out of `@cipherstash/stack`.
 - `packages/schema`: Schema builder utilities and types (`encryptedTable`, `encryptedColumn`, `encryptedField`)

From 872a0b4d3a599f51307d5e1d4e4934dd76d8ab89 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 16:45:10 -0600
Subject: [PATCH 12/21] fix(prisma-next): wire the v3 ORM surface end-to-end
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Gaps surfaced by converting the example app and driving the real CLI +
runtime rather than unit fixtures:

- CodecTypes/QueryOperationTypes cover all 40 v3 codec ids with
  trait-accurate operator visibility (cipherstash:v3-* marker traits;
  cipherstashJsonContains v3-only; storage-only domains surface no
  operator methods at the type level).
- The v3 runtime descriptor presents the pack id ('cipherstash') with
  v3's own version — the runtime matches contract extensionPacks by
  descriptor id, so the old distinct id failed startup with
  RUNTIME.MISSING_EXTENSION_PACK.
- Every v3 codec id registers a control-plane expandNativeType hook
  stripping the public. qualifier (the planner requires the hook for
  typeParams-carrying columns; bare names match introspected udt_name).
  No onFieldEvent — v3 emits zero add_search_config ops.
- The v3 bundle op is reclassified 'data': the integrity checker
  rejects self-edges without a data-class op.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/eql-v3-prisma-next.md              |   5 +
 .../migration.json                            |   2 +-
 .../migration.ts                              |  14 +-
 .../ops.json                                  |   2 +-
 packages/prisma-next/src/exports/control.ts   |  12 +-
 .../src/migration/cipherstash-codec-v3.ts     |  71 +++++
 packages/prisma-next/src/types/codec-types.ts | 268 ++++++++++++++++++
 .../prisma-next/src/types/operation-types.ts  |  54 +++-
 packages/prisma-next/src/v3/runtime-v3.ts     |  29 +-
 .../test/live/migration-apply-live-pg.test.ts |   2 +-
 .../live/side-by-side-clients-live-pg.test.ts |  13 +-
 .../test/operation-types.types.test-d.ts      |  82 ++++++
 .../test/v3/codec-types-v3.test-d.ts          | 121 ++++++++
 .../prisma-next/test/v3/migration-v3.test.ts  |   7 +-
 .../prisma-next/test/v3/runtime-v3.test.ts    |  12 +-
 15 files changed, 664 insertions(+), 30 deletions(-)
 create mode 100644 packages/prisma-next/src/migration/cipherstash-codec-v3.ts
 create mode 100644 packages/prisma-next/test/v3/codec-types-v3.test-d.ts

diff --git a/.changeset/eql-v3-prisma-next.md b/.changeset/eql-v3-prisma-next.md
index 0afc8841..c845f5a7 100644
--- a/.changeset/eql-v3-prisma-next.md
+++ b/.changeset/eql-v3-prisma-next.md
@@ -15,3 +15,8 @@
 - New `@cipherstash/prisma-next/v3` entry point: `cipherstashFromStackV3({ contractJson })` builds the v3 runtime descriptor, bulk-encrypt middleware, and a stack `EncryptionV3` client from the emitted contract.
 - Query operators (`cipherstashEq`, `cipherstashGt`, `cipherstashBetween`, `cipherstashInArray`, …) lower to `eql_v3.*` functions with operands cast to the domain's query type (`$n::eql_v3.query_<domain>`); `cipherstashIlike` maps to `eql_v3.contains` (bloom-filter token containment, not SQL `LIKE`); ordering uses `eql_v3.ord_term` / `eql_v3.ord_term_ore` by the column's ordering flavour. The domains are `public.eql_v3_*`; the operator functions live in the `eql_v3` schema.
 - A new baseline migration `20260601T0100_install_eql_v3_bundle` (invariant `cipherstash:install-eql-v3-bundle-v1`) installs the `public.eql_v3_*` domains and `eql_v3.*` functions from the pinned `@cipherstash/eql` release. Regenerate contracts and run migrations after changing constructors.
+- **The v3 ORM surface is fully wired end-to-end** (proven by converting `examples/prisma`):
+  - The generated `contract.d.ts` type surface covers every v3 codec id: `CodecTypes` gains all 40 `cipherstash/eql-v3/*@1` entries (envelope outputs — `number`-castAs domains decode to the new `EncryptedNumber` — plus trait-accurate operator visibility), and `QueryOperationTypes` gains `cipherstashJsonContains` and surfaces `cipherstashEq` / `cipherstashIlike` on v3 columns via type-level `cipherstash:v3-*` marker traits. Storage-only domains (including `EncryptedBoolean`) surface no operator methods at the type level, matching the runtime gate.
+  - The v3 runtime descriptor now presents the **pack id** (`cipherstash`) with v3's own version, so `postgres<Contract>({ extensions })` accepts contracts emitted by the cipherstash extension pack instead of failing with `RUNTIME.MISSING_EXTENSION_PACK`.
+  - Every v3 codec id registers a control-plane `expandNativeType` hook that strips the `public.` qualifier — `prisma-next migration plan` now renders `CREATE TABLE` columns as bare domain names (`eql_v3_bigint_ord`), matching what introspection reports, with **no `add_search_config` ops** (v3 domains carry their own index metadata). No `onFieldEvent` is registered for v3.
+  - The v3 bundle baseline migration op is reclassified `data` (it is a contract-shape-neutral self-edge; the aggregate integrity checker rejects self-edges without a data-class op), unblocking `prisma-next migration plan` / `migrate` in consuming apps.
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
index 8d45092b..c4a1bd9f 100644
--- a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.json
@@ -5,5 +5,5 @@
     "cipherstash:install-eql-v3-bundle-v1"
   ],
   "createdAt": "2026-07-14T20:10:24.325Z",
-  "migrationHash": "sha256:49917bcf99c88546e4edef9a6323a56045ea522313ee460674e0cc90d747b2c3"
+  "migrationHash": "sha256:d1ca5a987ab10eb85c2fe05700134b31f17f694d2d5b3df3969e902610b1d9cf"
 }
\ No newline at end of file
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
index 41db5b84..97eac30b 100644
--- a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/migration.ts
@@ -51,7 +51,19 @@ export default class M extends Migration {
       rawSql({
         id: 'cipherstash.install-eql-v3-bundle',
         label: INSTALL_LABEL,
-        operationClass: 'additive',
+        // `data`, not `additive`: this edge is a SELF-EDGE (`from ===
+        // to` — the bundle declares no contract-space storage), and the
+        // aggregate integrity checker (`migration-tools`
+        // `check-integrity.ts`) rejects a self-edge unless it carries a
+        // `data`-class op. Along the axis the checker classifies —
+        // does the op move the modeled contract shape? — `data` is the
+        // truthful answer: the bundle creates `public.eql_v3_*` domains
+        // and `eql_v3.*` functions the space contract deliberately does
+        // not model. (Contrast the v2 bundle op: `additive`, because
+        // its edge really moves the hash by adding the
+        // `eql_v2_configuration` table.) The `migrate` policy allows
+        // all four classes, so apply behaviour is unchanged.
+        operationClass: 'data',
         invariantId: CIPHERSTASH_V3_INVARIANTS.installBundle,
         target: { id: 'postgres' },
         precheck: [],
diff --git a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
index e19060fd..bf6e4398 100644
--- a/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
+++ b/packages/prisma-next/migrations/20260601T0100_install_eql_v3_bundle/ops.json
@@ -2,7 +2,7 @@
   {
     "id": "cipherstash.install-eql-v3-bundle",
     "label": "Install EQL v3 bundle (eql-3.0.0: public.eql_v3_* domains + eql_v3.* functions)",
-    "operationClass": "additive",
+    "operationClass": "data",
     "invariantId": "cipherstash:install-eql-v3-bundle-v1",
     "target": {
       "id": "postgres"
diff --git a/packages/prisma-next/src/exports/control.ts b/packages/prisma-next/src/exports/control.ts
index b037edc2..351de32b 100644
--- a/packages/prisma-next/src/exports/control.ts
+++ b/packages/prisma-next/src/exports/control.ts
@@ -65,6 +65,7 @@ import {
   cipherstashJsonCodecHooks,
   cipherstashStringCodecHooks,
 } from '../migration/cipherstash-codec'
+import { cipherstashV3CodecControlHooks } from '../migration/cipherstash-codec-v3'
 
 const cipherstashContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({
   contractJson,
@@ -76,9 +77,11 @@ const cipherstashContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({
     },
     // The v3 bundle baseline — an invariant-only edge (`from === to`;
     // the bundle creates `public.eql_v3_*` domains + `eql_v3.*`
-    // functions but no contract-space storage). NO v3 codec id is
-    // registered in `controlPlaneHooks` below: that omission is what
-    // guarantees v3 columns emit no `add_search_config` /
+    // functions but no contract-space storage). The v3 codec ids ARE
+    // registered in `controlPlaneHooks` below, but with the identity
+    // `expandNativeType` ONLY (the planner requires the hook to exist
+    // for `typeParams`-carrying columns) — no `onFieldEvent`, which is
+    // what guarantees v3 columns emit no `add_search_config` /
     // `remove_search_config` ops.
     {
       dirName: CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
@@ -111,6 +114,9 @@ const cipherstashExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>
       codecTypes: {
         ...cipherstashPackMeta.types.codecTypes,
         controlPlaneHooks: {
+          // v3: identity expandNativeType only, no onFieldEvent — see
+          // `../migration/cipherstash-codec-v3.ts`.
+          ...cipherstashV3CodecControlHooks,
           [CIPHERSTASH_STRING_CODEC_ID]: cipherstashStringCodecHooks,
           [CIPHERSTASH_DOUBLE_CODEC_ID]: cipherstashDoubleCodecHooks,
           [CIPHERSTASH_BIGINT_CODEC_ID]: cipherstashBigIntCodecHooks,
diff --git a/packages/prisma-next/src/migration/cipherstash-codec-v3.ts b/packages/prisma-next/src/migration/cipherstash-codec-v3.ts
new file mode 100644
index 00000000..9130e402
--- /dev/null
+++ b/packages/prisma-next/src/migration/cipherstash-codec-v3.ts
@@ -0,0 +1,71 @@
+/**
+ * Control-plane hooks for the EQL v3 codecs — a schema-stripping
+ * `expandNativeType` only, NO `onFieldEvent`.
+ *
+ * ## Why the hook must exist
+ *
+ * The Postgres planner requires an `expandNativeType` hook to EXIST for
+ * any column that carries `typeParams` (`expandParameterizedTypeSql` in
+ * target-postgres's `planner-ddl-builders.ts` throws otherwise), and
+ * every v3 column carries the static `{ castAs, capabilities }`
+ * typeParams block that v3 authoring emits.
+ *
+ * ## Why it strips `public.` instead of the v2 identity expansion
+ *
+ * The v3 contract `nativeType` is the schema-qualified domain
+ * (`public.eql_v3_bigint_ord`), and BOTH downstream consumers of this
+ * hook want the bare name:
+ *
+ *   - **DDL** (`buildColumnTypeSql`): an identity return means "no
+ *     expansion" and falls through to `assertSafeNativeType`, whose
+ *     `/^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/` pattern rejects the dot. The
+ *     stripped name renders `CREATE TABLE ... "x" eql_v3_bigint_ord`,
+ *     which resolves to the `public` schema via the search path — the
+ *     bundle creates every v3 domain in `public` by design.
+ *   - **Schema verify** (`renderExpectedNativeType`): the expected type
+ *     is compared against the introspected column's `udt_name`, which
+ *     Postgres reports UNQUALIFIED (`eql_v3_bigint_ord`). The stripped
+ *     name is exactly that spelling, so post-apply verification and
+ *     re-plan diffs see the column as clean.
+ *
+ * ## Deliberately NO `onFieldEvent`
+ *
+ * v3 needs no per-column search configuration (no
+ * `eql_v2.add_search_config` analogue exists — the domain itself
+ * carries the index metadata), so added/dropped/altered v3 columns
+ * contribute zero extra migration ops. `test/v3/migration-v3.test.ts`
+ * and the example app's e2e suite pin the absence of search-config ops
+ * end-to-end.
+ */
+
+import type { CodecControlHooks } from '@prisma-next/family-sql/control'
+import {
+  CIPHERSTASH_V3_CODEC_IDS,
+  type CipherstashV3CodecId,
+} from '../extension-metadata/constants-v3'
+
+const PUBLIC_SCHEMA_PREFIX = 'public.'
+
+const stripPublicSchema: NonNullable<CodecControlHooks['expandNativeType']> = ({
+  nativeType,
+}) =>
+  nativeType.startsWith(PUBLIC_SCHEMA_PREFIX)
+    ? nativeType.slice(PUBLIC_SCHEMA_PREFIX.length)
+    : nativeType
+
+const v3Hooks: CodecControlHooks = { expandNativeType: stripPublicSchema }
+
+/**
+ * One hooks entry per pinned v3 codec id, all sharing the
+ * schema-stripping `expandNativeType`. Spread into the control
+ * descriptor's `types.codecTypes.controlPlaneHooks` alongside the six
+ * v2 entries.
+ */
+export const cipherstashV3CodecControlHooks: Readonly<
+  Record<CipherstashV3CodecId, CodecControlHooks>
+> = Object.fromEntries(
+  CIPHERSTASH_V3_CODEC_IDS.map((codecId) => [codecId, v3Hooks]),
+  // Object.fromEntries widens keys to `string`; the entries are exactly
+  // the pinned `CIPHERSTASH_V3_CODEC_IDS` tuple, so the record type
+  // holds by construction.
+) as Record<CipherstashV3CodecId, CodecControlHooks>
diff --git a/packages/prisma-next/src/types/codec-types.ts b/packages/prisma-next/src/types/codec-types.ts
index df588c5b..d2629803 100644
--- a/packages/prisma-next/src/types/codec-types.ts
+++ b/packages/prisma-next/src/types/codec-types.ts
@@ -53,6 +53,63 @@ import type { EncryptedDate } from '../execution/envelope-date'
 import type { EncryptedDouble } from '../execution/envelope-double'
 import type { EncryptedJson } from '../execution/envelope-json'
 import type { EncryptedString } from '../execution/envelope-string'
+import type { EncryptedNumber } from '../v3/envelope-number'
+
+// ---------------------------------------------------------------------------
+// EQL v3 type-level trait vocabulary
+// ---------------------------------------------------------------------------
+//
+// The SHARED trait strings (`cipherstash:equality`, `cipherstash:
+// order-and-range`, `cipherstash:free-text-search`) appear on v3
+// entries exactly like on v2 entries: the trait-dispatched operator
+// methods (`cipherstashNe`, `cipherstashGt`, `cipherstashBetween`, …)
+// exist in BOTH runtime generations under the same names (decision 1b
+// keeps the method-name surface identical), so sharing the dispatch
+// trait is correct.
+//
+// The `cipherstash:v3-*` strings are TYPE-LEVEL MARKERS with no
+// runtime counterpart. They exist because three methods differ by
+// generation:
+//
+//   - `cipherstashEq` / `cipherstashIlike` are codec-id-pinned to
+//     `cipherstash/string@1` in the v2 runtime (legacy single-codec
+//     registration) but trait-dispatched in the v3 runtime. Their
+//     type-level `self` in `operation-types.ts` therefore declares
+//     BOTH a `codecId` (matched for v2 string columns) and a
+//     `traits: ['cipherstash:v3-equality' / 'cipherstash:v3-free-
+//     text-search']` marker (matched for v3 columns) — the
+//     framework's `OpMatchesField` tries codec-id first and falls
+//     through to traits.
+//   - `cipherstashJsonContains` exists ONLY in the v3 runtime, and
+//     `cipherstashJsonbPathExists` ONLY in the v2 runtime. The v3
+//     JSON entry deliberately carries `cipherstash:v3-searchable-json`
+//     INSTEAD of the shared `cipherstash:searchable-json` so each
+//     method surfaces only on the generation whose runtime registers
+//     it.
+//
+// Type-level visibility therefore never advertises a method the
+// column's runtime cannot dispatch.
+type V3TraitsNone = never
+type V3TraitsEq = 'cipherstash:equality' | 'cipherstash:v3-equality'
+type V3TraitsOrd = V3TraitsEq | 'cipherstash:order-and-range'
+type V3TraitsMatch =
+  | 'cipherstash:free-text-search'
+  | 'cipherstash:v3-free-text-search'
+type V3TraitsSearch = V3TraitsOrd | V3TraitsMatch
+type V3TraitsJson = 'cipherstash:v3-searchable-json'
+
+/**
+ * One v3 codec entry: `input` is the plaintext family or a pre-built
+ * envelope; `output` is the envelope class the v3 cell codec's
+ * `decode` constructs (per `envelopeTypeNameForCastAs`); `traits` is
+ * the type-level dispatch vocabulary above, derived from the domain's
+ * intrinsic query capabilities (see `v3/catalog.ts`).
+ */
+interface V3Codec<Plain, Envelope, Traits> {
+  readonly input: Plain | Envelope
+  readonly output: Envelope
+  readonly traits: Traits
+}
 
 export type CodecTypes = {
   readonly 'cipherstash/string@1': {
@@ -91,4 +148,215 @@ export type CodecTypes = {
     readonly output: EncryptedJson
     readonly traits: 'cipherstash:searchable-json'
   }
+
+  // -------------------------------------------------------------------------
+  // EQL v3 — one entry per catalog domain (all 40, including the
+  // authoring-unexposed `*_ord_ore` variants the codec layer still
+  // decodes). Keys are the pinned `CIPHERSTASH_V3_CODEC_IDS` literals
+  // (registry key VERBATIM); trait tiers mirror each domain's intrinsic
+  // query capabilities exactly (`test/v3/codec-types-v3.test-d.ts` pins
+  // both directions of the correspondence).
+  // -------------------------------------------------------------------------
+  readonly 'cipherstash/eql-v3/eql_v3_integer@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_integer_eq@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_integer_ord_ore@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_integer_ord@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_smallint@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_smallint_eq@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_smallint_ord_ore@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_smallint_ord@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_bigint@1': V3Codec<
+    bigint,
+    EncryptedBigInt,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_bigint_eq@1': V3Codec<
+    bigint,
+    EncryptedBigInt,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_bigint_ord_ore@1': V3Codec<
+    bigint,
+    EncryptedBigInt,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_bigint_ord@1': V3Codec<
+    bigint,
+    EncryptedBigInt,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_date@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_date_eq@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_date_ord_ore@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_date_ord@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_timestamp@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_timestamp_eq@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_timestamp_ord@1': V3Codec<
+    Date,
+    EncryptedDate,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_numeric@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_numeric_eq@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_numeric_ord_ore@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_numeric_ord@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text_eq@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text_match@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsMatch
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text_ord_ore@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text_ord@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_text_search@1': V3Codec<
+    string,
+    EncryptedString,
+    V3TraitsSearch
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_boolean@1': V3Codec<
+    boolean,
+    EncryptedBoolean,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_real@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_real_eq@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_real_ord_ore@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_real_ord@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_double@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsNone
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_double_eq@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsEq
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_double_ord_ore@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  readonly 'cipherstash/eql-v3/eql_v3_double_ord@1': V3Codec<
+    number,
+    EncryptedNumber,
+    V3TraitsOrd
+  >
+  // `unknown` subsumes `EncryptedJson` on the input side — same note
+  // as the v2 JSON entry above.
+  readonly 'cipherstash/eql-v3/eql_v3_json@1': {
+    readonly input: unknown
+    readonly output: EncryptedJson
+    readonly traits: V3TraitsJson
+  }
 }
diff --git a/packages/prisma-next/src/types/operation-types.ts b/packages/prisma-next/src/types/operation-types.ts
index a85d23bc..2069b927 100644
--- a/packages/prisma-next/src/types/operation-types.ts
+++ b/packages/prisma-next/src/types/operation-types.ts
@@ -83,6 +83,21 @@ type OrderAndRangeTraits = readonly ['cipherstash:order-and-range']
 type FreeTextSearchTraits = readonly ['cipherstash:free-text-search']
 type SearchableJsonTraits = readonly ['cipherstash:searchable-json']
 
+/**
+ * v3 TYPE-LEVEL marker traits (no runtime counterpart) — carried only
+ * by the v3 codec entries in `codec-types.ts` (see the vocabulary
+ * comment there). Three methods differ by runtime generation:
+ * `cipherstashEq` / `cipherstashIlike` are codec-id-pinned legacy
+ * registrations in v2 but trait-dispatched in v3, and
+ * `cipherstashJsonContains` (v3) / `cipherstashJsonbPathExists` (v2)
+ * exist in only one generation each. Dispatching those on the marker
+ * traits keeps type-level visibility exactly aligned with what each
+ * column's runtime can actually execute.
+ */
+type V3EqualityMarker = readonly ['cipherstash:v3-equality']
+type V3FreeTextSearchMarker = readonly ['cipherstash:v3-free-text-search']
+type V3SearchableJsonMarker = readonly ['cipherstash:v3-searchable-json']
+
 /**
  * Schematic constraint on `self` for a multi-codec cipherstash
  * predicate. The runtime impl reads `self.returnType.codecId` and
@@ -123,17 +138,33 @@ type AnyExpressionLike = Expression<{
 export type QueryOperationTypes<CT extends CodecTypesBase> =
   CT extends CodecTypesBase
     ? {
+        // `self` carries BOTH dispatch forms: `OpMatchesField` tries the
+        // codec-id branch first (matches the v2 legacy single-codec
+        // registration on `cipherstash/string@1`) and falls through to
+        // the traits branch (matches v3 columns via the type-level
+        // `cipherstash:v3-*` markers). v2 non-string columns match
+        // neither — their runtime has no `cipherstashEq` to dispatch.
+        // The comparand is `unknown` (not `pg/text@1`) because v3
+        // equality spans every equality-capable domain family (bigint,
+        // date, numeric, …), and the runtime coerces + encrypts the
+        // operand per the column's castAs.
         readonly cipherstashEq: {
-          readonly self: { readonly codecId: CipherstashStringCodec }
+          readonly self: {
+            readonly codecId: CipherstashStringCodec
+            readonly traits: V3EqualityMarker
+          }
           readonly impl: (
-            self: CodecExpression<CipherstashStringCodec, boolean, CT>,
-            other: CodecExpression<'pg/text@1', boolean, CT>,
+            self: AnyExpressionLike,
+            other: unknown,
           ) => PgBoolReturn
         }
         readonly cipherstashIlike: {
-          readonly self: { readonly codecId: CipherstashStringCodec }
+          readonly self: {
+            readonly codecId: CipherstashStringCodec
+            readonly traits: V3FreeTextSearchMarker
+          }
           readonly impl: (
-            self: CodecExpression<CipherstashStringCodec, boolean, CT>,
+            self: AnyExpressionLike,
             pattern: CodecExpression<'pg/text@1', boolean, CT>,
           ) => PgBoolReturn
         }
@@ -213,5 +244,18 @@ export type QueryOperationTypes<CT extends CodecTypesBase> =
           readonly self: { readonly traits: SearchableJsonTraits }
           readonly impl: (self: AnyExpressionLike, path: string) => PgBoolReturn
         }
+        // v3-only: encrypted jsonb `@>` containment on `eql_v3_json`
+        // columns. Dispatches on the v3 marker trait (NOT the shared
+        // `cipherstash:searchable-json`) so it never surfaces on v2
+        // JSON columns, whose runtime does not register the method —
+        // and, symmetrically, `cipherstashJsonbPathExists` above never
+        // surfaces on v3 columns.
+        readonly cipherstashJsonContains: {
+          readonly self: { readonly traits: V3SearchableJsonMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            needle: unknown,
+          ) => PgBoolReturn
+        }
       }
     : never
diff --git a/packages/prisma-next/src/v3/runtime-v3.ts b/packages/prisma-next/src/v3/runtime-v3.ts
index a7712ae8..e90b35a4 100644
--- a/packages/prisma-next/src/v3/runtime-v3.ts
+++ b/packages/prisma-next/src/v3/runtime-v3.ts
@@ -5,11 +5,23 @@
  *
  * Composes the SDK-bound v3 codec descriptors (Task 4, one per catalog
  * domain) and the v3 query operations (Task 6) into a single
- * `SqlRuntimeExtensionDescriptor<'postgres'>` under v3's OWN extension
- * id/version (decision 1b) — NOT the v2 `CIPHERSTASH_SPACE_ID` /
- * `CIPHERSTASH_EXTENSION_VERSION`. The registered method names
+ * `SqlRuntimeExtensionDescriptor<'postgres'>`.
+ *
+ * ## Descriptor id = the PACK id (`cipherstash`), version = v3's own
+ *
+ * The runtime asserts every extension pack the contract declares has a
+ * runtime descriptor with a MATCHING ID
+ * (`assertExecutionStackContractRequirements` in sql-runtime's
+ * `sql-context.ts`). Both v2 and v3 contracts are emitted by the ONE
+ * cipherstash control descriptor, whose pack id is
+ * `CIPHERSTASH_SPACE_ID` (`'cipherstash'`) — so the v3 runtime
+ * descriptor must present that id too, or `postgres<Contract>({...})`
+ * rejects a v3 contract at startup with
+ * `RUNTIME.MISSING_EXTENSION_PACK`. The descriptor's VERSION carries
+ * v3's own identity (`CIPHERSTASH_V3_EXTENSION_VERSION`), and decision
+ * 1b's separation holds regardless: the registered method names
  * (`cipherstashEq`, …) are identical to the v2 set, so the v2 and v3
- * descriptors must NEVER be co-registered in one client: the flat,
+ * descriptors must NEVER be co-registered in one client — the flat,
  * method-name-keyed `OperationRegistry` throws on the shared names
  * (pinned in `test/v3/operator-gating-v3.test.ts`). A client is v2 or
  * v3, never both.
@@ -22,10 +34,8 @@
 
 import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime'
 import type { CipherstashSdk } from '../execution/sdk'
-import {
-  CIPHERSTASH_V3_EXTENSION_VERSION,
-  CIPHERSTASH_V3_SPACE_ID,
-} from '../extension-metadata/constants-v3'
+import { CIPHERSTASH_SPACE_ID } from '../extension-metadata/constants'
+import { CIPHERSTASH_V3_EXTENSION_VERSION } from '../extension-metadata/constants-v3'
 import { createV3CodecDescriptors } from './codec-runtime-v3'
 import { cipherstashV3QueryOperations } from './operators-v3'
 
@@ -49,7 +59,8 @@ export function createCipherstashV3RuntimeDescriptor(
 
   return {
     kind: 'extension' as const,
-    id: CIPHERSTASH_V3_SPACE_ID,
+    // The PACK id, not CIPHERSTASH_V3_SPACE_ID — see the module header.
+    id: CIPHERSTASH_SPACE_ID,
     version: CIPHERSTASH_V3_EXTENSION_VERSION,
     familyId: 'sql' as const,
     targetId: 'postgres' as const,
diff --git a/packages/prisma-next/test/live/migration-apply-live-pg.test.ts b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
index 8f9b799d..df00d603 100644
--- a/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
+++ b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
@@ -76,7 +76,7 @@ describeLivePg('v3 baseline migration bundle against live Postgres', () => {
     const op = readOpsFixture()
     expect(op.id).toBe('cipherstash.install-eql-v3-bundle')
     expect(op.invariantId).toBe(CIPHERSTASH_V3_INVARIANTS.installBundle)
-    expect(op.operationClass).toBe('additive')
+    expect(op.operationClass).toBe('data')
     expect(op.execute).toHaveLength(1)
     // Byte identity: what installEqlV3IfNeeded just applied IS the
     // migration bundle a customer's `prisma-next migrate` applies.
diff --git a/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
index b12220f5..f61eba20 100644
--- a/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
+++ b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
@@ -24,7 +24,7 @@ import {
   CIPHERSTASH_SPACE_ID,
   CIPHERSTASH_STRING_CODEC_ID,
 } from '../../src/extension-metadata/constants'
-import { CIPHERSTASH_V3_SPACE_ID } from '../../src/extension-metadata/constants-v3'
+import { CIPHERSTASH_V3_EXTENSION_VERSION } from '../../src/extension-metadata/constants-v3'
 import { deriveStackSchemas } from '../../src/stack/derive-schemas'
 import {
   type CipherstashFromStackResult,
@@ -162,11 +162,16 @@ describeLivePg('v2 and v3 clients side by side against live Postgres', () => {
     if (sql) await sql.end()
   })
 
-  it('the two runtime descriptors carry distinct extension identities', () => {
-    expect(v3.cs.extensions[0]?.id).toBe(CIPHERSTASH_V3_SPACE_ID)
+  it('the two runtime descriptors share the pack id but carry distinct versions', () => {
+    // Both descriptors present the PACK id ('cipherstash') — the
+    // runtime matches contract extensionPacks by descriptor id, and one
+    // control descriptor emits both generations' contracts. Generation
+    // identity lives in the version.
+    expect(v3.cs.extensions[0]?.id).toBe(CIPHERSTASH_SPACE_ID)
+    expect(v3.cs.extensions[0]?.version).toBe(CIPHERSTASH_V3_EXTENSION_VERSION)
     if (v2) {
       expect(v2.extensions[0]?.id).toBe(CIPHERSTASH_SPACE_ID)
-      expect(v2.extensions[0]?.id).not.toBe(v3.cs.extensions[0]?.id)
+      expect(v2.extensions[0]?.version).not.toBe(v3.cs.extensions[0]?.version)
     }
   })
 
diff --git a/packages/prisma-next/test/operation-types.types.test-d.ts b/packages/prisma-next/test/operation-types.types.test-d.ts
index 0fae5683..334c39d3 100644
--- a/packages/prisma-next/test/operation-types.types.test-d.ts
+++ b/packages/prisma-next/test/operation-types.types.test-d.ts
@@ -29,6 +29,7 @@
  * type-test files; this is one of them.
  */
 
+import type { CodecTypes as RealCodecTypes } from '../src/types/codec-types'
 import type { QueryOperationTypes } from '../src/types/operation-types'
 
 // -- Synthetic CodecTypes table ----------------------------------------------
@@ -228,9 +229,90 @@ type _jpe_string_neg = Expect<
 // @ts-expect-error cipherstashJsonbPathExists must not surface on pg/text@1.
 type _jpe_text_neg = Expect<M<'cipherstashJsonbPathExists', 'pg/text@1'>>
 
+// -- EQL v3 dispatch (against the REAL CodecTypes table) ---------------------
+//
+// The v3 assertions run against the real `CodecTypes` export (which
+// carries the 40 v3 entries plus the `cipherstash:v3-*` type-level
+// markers) rather than the synthetic table above, so drift in the real
+// table breaks this file. Pins the generation-split contracts:
+//
+//   - `cipherstashEq` / `cipherstashIlike` (codec-id-pinned in v2)
+//     surface on v3 columns via the marker-trait fall-through.
+//   - `cipherstashJsonContains` is v3-json-only; the v2-only
+//     `cipherstashJsonbPathExists` must NOT surface on v3 json.
+//   - Storage-only v3 domains (boolean, bare `eql_v3_text`) surface
+//     NO cipherstash operators at all.
+
+type RealOps = QueryOperationTypes<RealCodecTypes>
+type M3<N extends keyof RealOps, C extends string> = OpMatchesField<
+  RealOps[N],
+  C,
+  RealCodecTypes
+>
+
+type _v3_eq_search_pos = Expect<
+  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+>
+type _v3_eq_bigint_eq_pos = Expect<
+  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_bigint_eq@1'>
+>
+type _v3_eq_boolean_neg = Expect<
+  // @ts-expect-error cipherstashEq must not surface on storage-only eql_v3_boolean.
+  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_boolean@1'>
+>
+type _v3_eq_text_storage_neg = Expect<
+  // @ts-expect-error cipherstashEq must not surface on storage-only eql_v3_text.
+  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_text@1'>
+>
+type _v3_ilike_search_pos = Expect<
+  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+>
+type _v3_ilike_match_pos = Expect<
+  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_match@1'>
+>
+type _v3_ilike_eq_neg = Expect<
+  // @ts-expect-error cipherstashIlike must not surface on eql_v3_text_eq (no free-text index).
+  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_eq@1'>
+>
+type _v3_gt_ord_pos = Expect<
+  M3<'cipherstashGt', 'cipherstash/eql-v3/eql_v3_double_ord@1'>
+>
+type _v3_gt_eqonly_neg = Expect<
+  // @ts-expect-error cipherstashGt must not surface on eql_v3_double_eq (no order/range).
+  M3<'cipherstashGt', 'cipherstash/eql-v3/eql_v3_double_eq@1'>
+>
+type _v3_ina_boolean_neg = Expect<
+  // @ts-expect-error cipherstashInArray must not surface on storage-only eql_v3_boolean.
+  M3<'cipherstashInArray', 'cipherstash/eql-v3/eql_v3_boolean@1'>
+>
+type _v3_jsoncontains_json_pos = Expect<
+  M3<'cipherstashJsonContains', 'cipherstash/eql-v3/eql_v3_json@1'>
+>
+type _v3_jsoncontains_v2json_neg = Expect<
+  // @ts-expect-error cipherstashJsonContains must not surface on the v2 json codec.
+  M3<'cipherstashJsonContains', 'cipherstash/json@1'>
+>
+type _v3_jpe_v3json_neg = Expect<
+  // @ts-expect-error v2-only cipherstashJsonbPathExists must not surface on eql_v3_json.
+  M3<'cipherstashJsonbPathExists', 'cipherstash/eql-v3/eql_v3_json@1'>
+>
+
 // -- Anchor unused type aliases so noUnusedLocals stays happy ---------------
 
 export type _Anchors = [
+  _v3_eq_search_pos,
+  _v3_eq_bigint_eq_pos,
+  _v3_eq_boolean_neg,
+  _v3_eq_text_storage_neg,
+  _v3_ilike_search_pos,
+  _v3_ilike_match_pos,
+  _v3_ilike_eq_neg,
+  _v3_gt_ord_pos,
+  _v3_gt_eqonly_neg,
+  _v3_ina_boolean_neg,
+  _v3_jsoncontains_json_pos,
+  _v3_jsoncontains_v2json_neg,
+  _v3_jpe_v3json_neg,
   _eq_string_pos,
   _eq_double_neg,
   _eq_text_neg,
diff --git a/packages/prisma-next/test/v3/codec-types-v3.test-d.ts b/packages/prisma-next/test/v3/codec-types-v3.test-d.ts
new file mode 100644
index 00000000..04fcfde2
--- /dev/null
+++ b/packages/prisma-next/test/v3/codec-types-v3.test-d.ts
@@ -0,0 +1,121 @@
+/**
+ * Type-level drift guards for the EQL v3 entries in
+ * `src/types/codec-types.ts`.
+ *
+ * The v3 block of the `CodecTypes` table is hand-written (same
+ * rationale as the v2 block: the literal `cipherstash:*` trait strings
+ * must survive, which `ExtractCodecTypes` would collapse). These
+ * assertions keep it honest against the pinned codec-id union and the
+ * per-domain capability tiers:
+ *
+ *   1. Every pinned `CipherstashV3CodecId` has a `CodecTypes` entry,
+ *      and (2) no `cipherstash/eql-v3/...` entry exists outside the
+ *      pinned union — the table and the catalog can only drift
+ *      together, and `constants-v3.ts` already locks the catalog.
+ *   3. Spot-pins for each capability tier: output envelope class and
+ *      the exact type-level trait union (shared strings + `v3-*`
+ *      markers) for a representative domain per tier.
+ *
+ * AGENTS.md permits `@ts-expect-error` exclusively in negative
+ * type-test files; this is one of them.
+ */
+
+import { describe, expectTypeOf, it } from 'vitest'
+import type { EncryptedBigInt } from '../../src/execution/envelope-bigint'
+import type { EncryptedBoolean } from '../../src/execution/envelope-boolean'
+import type { EncryptedJson } from '../../src/execution/envelope-json'
+import type { EncryptedString } from '../../src/execution/envelope-string'
+import type { CipherstashV3CodecId } from '../../src/extension-metadata/constants-v3'
+import type { CodecTypes } from '../../src/types/codec-types'
+import type { EncryptedNumber } from '../../src/v3/envelope-number'
+
+// -- 1. Every pinned v3 codec id has a CodecTypes entry ----------------------
+
+type MissingFromCodecTypes = Exclude<CipherstashV3CodecId, keyof CodecTypes>
+type _AllPinnedIdsCovered = [MissingFromCodecTypes] extends [never]
+  ? true
+  : ['CodecTypes is missing v3 entries', MissingFromCodecTypes]
+const _allPinnedIdsCovered: _AllPinnedIdsCovered = true
+void _allPinnedIdsCovered
+
+// -- 2. No v3-shaped CodecTypes key outside the pinned union -----------------
+
+type V3ShapedKeys = Extract<keyof CodecTypes, `cipherstash/eql-v3/${string}`>
+type UnpinnedEntries = Exclude<V3ShapedKeys, CipherstashV3CodecId>
+type _NoUnpinnedEntries = [UnpinnedEntries] extends [never]
+  ? true
+  : ['CodecTypes has v3 entries the pinned union does not', UnpinnedEntries]
+const _noUnpinnedEntries: _NoUnpinnedEntries = true
+void _noUnpinnedEntries
+
+// -- 3. Per-tier spot pins ----------------------------------------------------
+
+describe('v3 CodecTypes entries', () => {
+  it('storage-only domains carry no type-level traits', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['traits']
+    >().toEqualTypeOf<never>()
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['output']
+    >().toEqualTypeOf<EncryptedBoolean>()
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_text@1']['traits']
+    >().toEqualTypeOf<never>()
+  })
+
+  it('_eq domains carry equality + the v3-equality marker', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_bigint_eq@1']['traits']
+    >().toEqualTypeOf<'cipherstash:equality' | 'cipherstash:v3-equality'>()
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_bigint_eq@1']['output']
+    >().toEqualTypeOf<EncryptedBigInt>()
+  })
+
+  it('_ord domains add order-and-range', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['traits']
+    >().toEqualTypeOf<
+      | 'cipherstash:equality'
+      | 'cipherstash:v3-equality'
+      | 'cipherstash:order-and-range'
+    >()
+    // v3 `number`-castAs domains decode to EncryptedNumber, NOT the v2
+    // EncryptedDouble.
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['output']
+    >().toEqualTypeOf<EncryptedNumber>()
+  })
+
+  it('text_match carries only the free-text pair', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_text_match@1']['traits']
+    >().toEqualTypeOf<
+      'cipherstash:free-text-search' | 'cipherstash:v3-free-text-search'
+    >()
+  })
+
+  it('text_search carries the full scalar tier', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['traits']
+    >().toEqualTypeOf<
+      | 'cipherstash:equality'
+      | 'cipherstash:v3-equality'
+      | 'cipherstash:order-and-range'
+      | 'cipherstash:free-text-search'
+      | 'cipherstash:v3-free-text-search'
+    >()
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['output']
+    >().toEqualTypeOf<EncryptedString>()
+  })
+
+  it('json carries ONLY the v3-searchable-json marker (v2 jsonb-path methods must not surface)', () => {
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['traits']
+    >().toEqualTypeOf<'cipherstash:v3-searchable-json'>()
+    expectTypeOf<
+      CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['output']
+    >().toEqualTypeOf<EncryptedJson>()
+  })
+})
diff --git a/packages/prisma-next/test/v3/migration-v3.test.ts b/packages/prisma-next/test/v3/migration-v3.test.ts
index 1521125a..39abad3f 100644
--- a/packages/prisma-next/test/v3/migration-v3.test.ts
+++ b/packages/prisma-next/test/v3/migration-v3.test.ts
@@ -27,13 +27,16 @@ import {
 } from '../../src/extension-metadata/constants-v3'
 
 describe('v3 baseline migration (20260601T0100_install_eql_v3_bundle)', () => {
-  it('installs under the v3 invariant with a single additive rawSql op', () => {
+  it('installs under the v3 invariant with a single data-class rawSql op', () => {
     expect(v3Ops).toHaveLength(1)
     const op = (v3Ops as Array<Record<string, unknown>>)[0]!
     expect(op.id).toBe('cipherstash.install-eql-v3-bundle')
     expect(op.invariantId).toBe(CIPHERSTASH_V3_INVARIANTS.installBundle)
     expect(op.invariantId).toBe('cipherstash:install-eql-v3-bundle-v1')
-    expect(op.operationClass).toBe('additive')
+    // `data`, not `additive`: the edge is a self-edge (from === to),
+    // and the aggregate integrity checker rejects self-edges without a
+    // data-class op — see the rationale comment in the migration file.
+    expect(op.operationClass).toBe('data')
   })
 
   it('inlines the @cipherstash/eql install SQL byte-for-byte through ops.json', () => {
diff --git a/packages/prisma-next/test/v3/runtime-v3.test.ts b/packages/prisma-next/test/v3/runtime-v3.test.ts
index e51e5a5f..8559229b 100644
--- a/packages/prisma-next/test/v3/runtime-v3.test.ts
+++ b/packages/prisma-next/test/v3/runtime-v3.test.ts
@@ -33,11 +33,17 @@ function emptySdk(): CipherstashSdk {
 }
 
 describe('createCipherstashV3RuntimeDescriptor — descriptor shape', () => {
-  it('declares kind=extension under the v3 id/version (never the v2 id)', () => {
+  it('declares kind=extension under the PACK id with the v3 version', () => {
     const descriptor = createCipherstashV3RuntimeDescriptor({ sdk: emptySdk() })
     expect(descriptor.kind).toBe('extension')
-    expect(descriptor.id).toBe(CIPHERSTASH_V3_SPACE_ID)
-    expect(descriptor.id).not.toBe(CIPHERSTASH_SPACE_ID)
+    // The id must be the PACK id ('cipherstash'): the runtime matches
+    // the contract's declared extensionPacks against runtime descriptor
+    // ids, and both generations' contracts are emitted by the one
+    // cipherstash control descriptor. The VERSION carries v3's own
+    // identity. (CIPHERSTASH_V3_SPACE_ID remains v3's logical space
+    // identity but is deliberately NOT the runtime descriptor id.)
+    expect(descriptor.id).toBe(CIPHERSTASH_SPACE_ID)
+    expect(descriptor.id).not.toBe(CIPHERSTASH_V3_SPACE_ID)
     expect(descriptor.version).toBe(CIPHERSTASH_V3_EXTENSION_VERSION)
     expect(descriptor.familyId).toBe('sql')
     expect(descriptor.targetId).toBe('postgres')

From a0f5ee0c9627e32c51a432328dc1fe77419a6c73 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Tue, 14 Jul 2026 16:45:30 -0600
Subject: [PATCH 13/21] feat(prisma-example): convert the example app to EQL v3
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Schema: every column is a concrete public.eql_v3_* domain
(EncryptedTextSearch / EncryptedDoubleOrd / EncryptedBigIntOrd /
EncryptedDateOrd / EncryptedBoolean / EncryptedJson); wiring via
cipherstashFromStackV3. Migrations regenerated from the v3 contract —
initial app migration carries zero add_search_config ops; the
cipherstash space ships both bundle baselines.

E2E suites adapted to the v3 surface and green from a wiped database
(7 files / 40 tests, live PG + ZeroKMS): equality/range/free-text
tokens, order-term sorting, JSON @> containment (positive, negative,
multi-key, nested, empty-needle rejection), lossless bigint beyond
MAX_SAFE_INTEGER, and eql_v3_boolean's storage-only operator refusal
pinned as a feature. README walkthrough e2e (repo-level) also green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/prisma-example-eql-v3.md           |   5 +
 examples/prisma/README.md                     |  53 ++--
 .../app/20260709T1034_initial/migration.json  |  19 --
 .../app/20260709T1034_initial/migration.ts    | 144 -----------
 .../app/20260709T1034_initial/ops.json        | 228 ------------------
 .../end-contract.d.ts                         | 172 +++++++++----
 .../end-contract.json                         | 114 +++++----
 .../app/20260714T2142_initial/migration.json  |   7 +
 .../app/20260714T2142_initial/migration.ts    |  95 ++++++++
 .../app/20260714T2142_initial/ops.json        |  41 ++++
 .../migration.json                            |   9 +
 .../ops.json                                  |  32 +++
 .../migrations/cipherstash/refs/head.json     |   2 +-
 examples/prisma/prisma/schema.prisma          |  69 +++---
 examples/prisma/src/db.ts                     |  25 +-
 examples/prisma/src/index.ts                  | 112 ++++++---
 examples/prisma/src/prisma/contract.d.ts      | 172 +++++++++----
 examples/prisma/src/prisma/contract.json      | 114 +++++----
 examples/prisma/test/e2e/README.md            |  37 ++-
 examples/prisma/test/e2e/bigint.e2e.test.ts   |  79 +++---
 examples/prisma/test/e2e/bool.e2e.test.ts     | 129 ++++++----
 examples/prisma/test/e2e/date.e2e.test.ts     |  34 +--
 examples/prisma/test/e2e/global-setup.ts      |  12 +-
 examples/prisma/test/e2e/json.e2e.test.ts     | 151 +++++++-----
 examples/prisma/test/e2e/mixed.e2e.test.ts    | 114 ++++-----
 examples/prisma/test/e2e/num.e2e.test.ts      |  43 ++--
 .../prisma/test/e2e/str-range.e2e.test.ts     |  59 +++--
 27 files changed, 1113 insertions(+), 958 deletions(-)
 create mode 100644 .changeset/prisma-example-eql-v3.md
 delete mode 100644 examples/prisma/migrations/app/20260709T1034_initial/migration.json
 delete mode 100755 examples/prisma/migrations/app/20260709T1034_initial/migration.ts
 delete mode 100644 examples/prisma/migrations/app/20260709T1034_initial/ops.json
 rename examples/prisma/migrations/app/{20260709T1034_initial => 20260714T2142_initial}/end-contract.d.ts (71%)
 rename examples/prisma/migrations/app/{20260709T1034_initial => 20260714T2142_initial}/end-contract.json (79%)
 create mode 100644 examples/prisma/migrations/app/20260714T2142_initial/migration.json
 create mode 100755 examples/prisma/migrations/app/20260714T2142_initial/migration.ts
 create mode 100644 examples/prisma/migrations/app/20260714T2142_initial/ops.json
 create mode 100644 examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json
 create mode 100644 examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json

diff --git a/.changeset/prisma-example-eql-v3.md b/.changeset/prisma-example-eql-v3.md
new file mode 100644
index 00000000..955c2e07
--- /dev/null
+++ b/.changeset/prisma-example-eql-v3.md
@@ -0,0 +1,5 @@
+---
+'@cipherstash/prisma-next-example': minor
+---
+
+Convert the example app to EQL v3. Every column is now a concrete `public.eql_v3_*` domain authored with the per-domain constructors (`EncryptedTextSearch`, `EncryptedDoubleOrd`, `EncryptedBigIntOrd`, `EncryptedDateOrd`, `EncryptedBoolean`, `EncryptedJson`), wired through `cipherstashFromStackV3({ contractJson })`. The e2e harness runs the full v3 surface against live Postgres + ZeroKMS with no skips: equality/range/free-text-token operators, `cipherstashV3Asc`/`Desc` order-term sorting, encrypted JSON containment (`cipherstashJsonContains` — the v2 `cipherstashJsonb*` helpers do not exist in v3), lossless `bigint` beyond `Number.MAX_SAFE_INTEGER`, and the storage-only `eql_v3_boolean` refusal (`EncryptionOperatorError`) pinned as a feature. Migrations regenerate from the v3 contract: the initial app migration creates the `users` table against the v3 domains with zero `add_search_config` ops, and the cipherstash space carries both bundle baselines (v2 + v3).
diff --git a/examples/prisma/README.md b/examples/prisma/README.md
index 6977e55d..664ae274 100644
--- a/examples/prisma/README.md
+++ b/examples/prisma/README.md
@@ -1,8 +1,17 @@
 # @cipherstash/prisma-next example
 
-End-to-end demo of [`@cipherstash/prisma-next`](../../packages/prisma-next/README.md): searchable application-layer encryption for Postgres with [Prisma Next](https://www.npmjs.com/package/@prisma-next/cli), using [`@cipherstash/stack`](../../packages/stack/README.md) as the encryption SDK.
+End-to-end demo of [`@cipherstash/prisma-next`](../../packages/prisma-next/README.md): searchable application-layer encryption for Postgres with [Prisma Next](https://www.npmjs.com/package/@prisma-next/cli), using [`@cipherstash/stack`](../../packages/stack/README.md) as the encryption SDK — on **EQL v3**, where every encrypted column is a concrete `public.eql_v3_*` Postgres domain and the constructor you pick *is* the capability set.
 
-A single `User` model with one column per cipherstash codec (string, double, bigint, date, boolean, JSON), exercised end-to-end: insert, equality, free-text search, range, between, in-array, sort, and `decryptAll`-amortised read.
+A single `User` model with one column per plaintext family, exercised end-to-end: insert, equality, free-text token search, range, between, in-array, encrypted-order-term sort, JSON containment, and `decryptAll`-amortised read.
+
+| Column          | Constructor                       | Domain                | Query surface                          |
+| --------------- | --------------------------------- | --------------------- | -------------------------------------- |
+| `email`         | `cipherstash.EncryptedTextSearch()` | `eql_v3_text_search` | equality + order/range + free-text     |
+| `salary`        | `cipherstash.EncryptedDoubleOrd()`  | `eql_v3_double_ord`  | equality + order/range                 |
+| `accountId`     | `cipherstash.EncryptedBigIntOrd()`  | `eql_v3_bigint_ord`  | equality + order/range (true `bigint`) |
+| `birthday`      | `cipherstash.EncryptedDateOrd()`    | `eql_v3_date_ord`    | equality + order/range                 |
+| `emailVerified` | `cipherstash.EncryptedBoolean()`    | `eql_v3_boolean`     | storage-only (no operators)            |
+| `preferences`   | `cipherstash.EncryptedJson()`       | `eql_v3_json`        | `cipherstashJsonContains` (`@>`)       |
 
 📖 See the [Prisma Next encryption docs](https://cipherstash.com/docs/stack/cipherstash/encryption/prisma-next) for the full operator reference, security model, and known limitations.
 
@@ -11,12 +20,12 @@ A single `User` model with one column per cipherstash codec (string, double, big
 | Path                       | Purpose                                                                                       |
 | -------------------------- | --------------------------------------------------------------------------------------------- |
 | `docker-compose.yml`       | Local Postgres 16 on port 54338.                                                               |
-| `prisma/schema.prisma`     | Application schema (one `User` model exercising all six cipherstash codecs).                  |
+| `prisma/schema.prisma`     | Application schema (one `User` model exercising six cipherstash v3 domains).                  |
 | `prisma-next.config.ts`    | Wires `cipherstash` into `extensionPacks`.                                                    |
-| `src/db.ts`                | One-call setup via `cipherstashFromStack({ contractJson })`.                                  |
+| `src/db.ts`                | One-call setup via `cipherstashFromStackV3({ contractJson })`.                                |
 | `src/index.ts`             | The demo flow.                                                                                |
 | `src/prisma/contract.*`    | Emitted by `pnpm emit`.                                                                       |
-| `migrations/`              | Emitted by `pnpm migration:plan`.                                                             |
+| `migrations/`              | Emitted by `pnpm migration:plan` (app space + the cipherstash EQL bundle baselines).          |
 
 ## Prerequisites
 
@@ -33,7 +42,7 @@ docker compose up -d
 pnpm install
 pnpm emit                  # PSL → contract.{json,d.ts}
 pnpm migration:plan --name initial
-pnpm migration:apply       # installs EQL bundle + your app schema in one sweep (runs `prisma-next migrate`)
+pnpm migration:apply       # installs the EQL bundles + your app schema in one sweep (runs `prisma-next migrate`)
 pnpm start                 # runs the demo
 ```
 
@@ -52,40 +61,50 @@ pnpm install && pnpm emit && pnpm typecheck
 ## Expected output
 
 ```text
---- Insert (mixed-codec round-trip) ---
-Inserted 4 rows across six cipherstash codecs.
+--- Insert (mixed-domain round-trip) ---
+Inserted 4 rows across six cipherstash v3 domains.
 
---- cipherstashEq (string equality) ---
+--- cipherstashEq (text_search equality) ---
 Found 1 row(s) for alice@example.com.
   user-0: alice@example.com
 
---- cipherstashIlike (string free-text-search) ---
-Found 3 row(s) matching %@example.com.
+--- cipherstashIlike (text_search free-text tokens) ---
+Found 3 row(s) whose email contains example.com.
   user-0: alice@example.com
   user-1: bob@example.com
   user-2: carol@example.com
 
---- cipherstashGt (double order-and-range) ---
+--- cipherstashGt (double_ord order-and-range) ---
 Found 2 user(s) with salary > 100,000.
   user-1: salary=110000
   user-3: salary=145000
 
---- cipherstashBetween (date order-and-range) ---
+--- cipherstashBetween (date_ord order-and-range) ---
 Found 3 user(s) born between 1985 and 1995.
 
---- cipherstashInArray (bigint equality) ---
+--- cipherstashInArray (bigint_ord equality) ---
 Found 2 user(s) whose accountId is in the supplied array.
 
---- cipherstashInArray (boolean equality-only) ---
-Found 3 user(s) with emailVerified = true.
+--- eql_v3_boolean (storage-only round-trip) ---
+  user-2: emailVerified=false
+
+--- cipherstashJsonContains (encrypted jsonb @>) ---
+Found 2 user(s) with a dark-theme preference.
+  user-0: {"theme":"dark","notifications":true}
+  user-2: {"theme":"dark","notifications":true}
 
---- cipherstashAsc (bare-column ORDER BY) ---
+--- cipherstashV3Asc (encrypted order-term ORDER BY) ---
   user-0: email=alice@example.com
   user-1: email=bob@example.com
   user-2: email=carol@example.com
   user-3: email=dave@otherorg.test
 ```
 
+Two v3 behaviours worth noticing in that output:
+
+- **`cipherstashIlike` is bloom-filter token containment** (`eql_v3.contains`), not SQL `ILIKE` — the needle's tokens must appear in the ciphertext's index. Plain substrings like `example.com` are the idiomatic needle; `%` wildcards are not part of the model.
+- **`eql_v3_boolean` is storage-only.** It round-trips `true`/`false` losslessly but surfaces no search operators — calling one throws `EncryptionOperatorError`. Filter on a searchable column and decrypt the boolean from the result set.
+
 ## References
 
 - 📖 [Prisma Next encryption docs](https://cipherstash.com/docs/stack/cipherstash/encryption/prisma-next) — the canonical reference.
diff --git a/examples/prisma/migrations/app/20260709T1034_initial/migration.json b/examples/prisma/migrations/app/20260709T1034_initial/migration.json
deleted file mode 100644
index 14b8ed39..00000000
--- a/examples/prisma/migrations/app/20260709T1034_initial/migration.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-  "from": null,
-  "to": "sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa",
-  "providedInvariants": [
-    "cipherstash-codec:users.accountid:add-search-config:ore@v1",
-    "cipherstash-codec:users.accountid:add-search-config:unique@v1",
-    "cipherstash-codec:users.birthday:add-search-config:ore@v1",
-    "cipherstash-codec:users.birthday:add-search-config:unique@v1",
-    "cipherstash-codec:users.email:add-search-config:match@v1",
-    "cipherstash-codec:users.email:add-search-config:ore@v1",
-    "cipherstash-codec:users.email:add-search-config:unique@v1",
-    "cipherstash-codec:users.emailverified:add-search-config:unique@v1",
-    "cipherstash-codec:users.preferences:add-search-config:ste_vec@v1",
-    "cipherstash-codec:users.salary:add-search-config:ore@v1",
-    "cipherstash-codec:users.salary:add-search-config:unique@v1"
-  ],
-  "createdAt": "2026-07-09T10:34:08.902Z",
-  "migrationHash": "sha256:4cce7dab1306568bb00184c15d1b82f6c5a1f61adb6b37a211b917adc4e71200"
-}
\ No newline at end of file
diff --git a/examples/prisma/migrations/app/20260709T1034_initial/migration.ts b/examples/prisma/migrations/app/20260709T1034_initial/migration.ts
deleted file mode 100755
index 711d9eb6..00000000
--- a/examples/prisma/migrations/app/20260709T1034_initial/migration.ts
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/env -S node
-import { cipherstashAddSearchConfig } from '@prisma-next/extension-cipherstash/migration'
-import {
-  col,
-  Migration,
-  MigrationCLI,
-  primaryKey,
-} from '@prisma-next/postgres/migration'
-
-export default class M extends Migration {
-  override describe() {
-    return {
-      from: null,
-      to: 'sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa',
-    }
-  }
-
-  override get operations() {
-    return [
-      this.createTable({
-        schema: 'public',
-        table: 'users',
-        columns: [
-          col('accountid', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/bigint@1',
-              typeParams: { equality: true, orderAndRange: true },
-            },
-          }),
-          col('birthday', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/date@1',
-              typeParams: { equality: true, orderAndRange: true },
-            },
-          }),
-          col('email', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/string@1',
-              typeParams: {
-                equality: true,
-                freeTextSearch: true,
-                orderAndRange: true,
-              },
-            },
-          }),
-          col('emailverified', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/boolean@1',
-              typeParams: { equality: true },
-            },
-          }),
-          col('id', 'text', {
-            notNull: true,
-            codecRef: { codecId: 'pg/text@1' },
-          }),
-          col('preferences', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/json@1',
-              typeParams: { searchableJson: true },
-            },
-          }),
-          col('salary', 'eql_v2_encrypted', {
-            notNull: true,
-            codecRef: {
-              codecId: 'cipherstash/double@1',
-              typeParams: { equality: true, orderAndRange: true },
-            },
-          }),
-        ],
-        constraints: [primaryKey(['id'])],
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'accountid',
-        index: 'unique',
-        castAs: 'big_int',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'accountid',
-        index: 'ore',
-        castAs: 'big_int',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'birthday',
-        index: 'unique',
-        castAs: 'date',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'birthday',
-        index: 'ore',
-        castAs: 'date',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'email',
-        index: 'unique',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'email',
-        index: 'match',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'email',
-        index: 'ore',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'emailverified',
-        index: 'unique',
-        castAs: 'boolean',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'preferences',
-        index: 'ste_vec',
-        castAs: 'jsonb',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'salary',
-        index: 'unique',
-        castAs: 'double',
-      }),
-      cipherstashAddSearchConfig({
-        table: 'users',
-        column: 'salary',
-        index: 'ore',
-        castAs: 'double',
-      }),
-    ]
-  }
-}
-
-MigrationCLI.run(import.meta.url, M)
diff --git a/examples/prisma/migrations/app/20260709T1034_initial/ops.json b/examples/prisma/migrations/app/20260709T1034_initial/ops.json
deleted file mode 100644
index 72baac1a..00000000
--- a/examples/prisma/migrations/app/20260709T1034_initial/ops.json
+++ /dev/null
@@ -1,228 +0,0 @@
-[
-  {
-    "id": "table.users",
-    "label": "Create table \"users\"",
-    "summary": "Creates table \"users\"",
-    "operationClass": "additive",
-    "target": {
-      "id": "postgres",
-      "details": {
-        "schema": "public",
-        "objectType": "table",
-        "name": "users"
-      }
-    },
-    "precheck": [
-      {
-        "description": "ensure table \"users\" does not exist",
-        "sql": "SELECT (to_regclass($1)) IS NULL AS \"result\"",
-        "params": [
-          "\"public\".\"users\""
-        ]
-      }
-    ],
-    "execute": [
-      {
-        "description": "create table \"users\"",
-        "sql": "CREATE TABLE \"public\".\"users\" (\n  \"accountid\" eql_v2_encrypted NOT NULL,\n  \"birthday\" eql_v2_encrypted NOT NULL,\n  \"email\" eql_v2_encrypted NOT NULL,\n  \"emailverified\" eql_v2_encrypted NOT NULL,\n  \"id\" text NOT NULL,\n  \"preferences\" eql_v2_encrypted NOT NULL,\n  \"salary\" eql_v2_encrypted NOT NULL,\n  PRIMARY KEY (\"id\")\n)",
-        "params": []
-      }
-    ],
-    "postcheck": [
-      {
-        "description": "verify table \"users\" exists",
-        "sql": "SELECT (to_regclass($1)) IS NOT NULL AS \"result\"",
-        "params": [
-          "\"public\".\"users\""
-        ]
-      }
-    ]
-  },
-  {
-    "id": "cipherstash-codec.users.accountid.add-search-config.unique",
-    "label": "Enable cipherstash search on users.accountid",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.accountid:add-search-config:unique@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash unique search config for users.accountid",
-        "sql": "SELECT eql_v2.add_search_config('users', 'accountid', 'unique', 'big_int');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.accountid.add-search-config.ore",
-    "label": "Enable cipherstash search on users.accountid",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.accountid:add-search-config:ore@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash ore search config for users.accountid",
-        "sql": "SELECT eql_v2.add_search_config('users', 'accountid', 'ore', 'big_int');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.birthday.add-search-config.unique",
-    "label": "Enable cipherstash search on users.birthday",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.birthday:add-search-config:unique@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash unique search config for users.birthday",
-        "sql": "SELECT eql_v2.add_search_config('users', 'birthday', 'unique', 'date');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.birthday.add-search-config.ore",
-    "label": "Enable cipherstash search on users.birthday",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.birthday:add-search-config:ore@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash ore search config for users.birthday",
-        "sql": "SELECT eql_v2.add_search_config('users', 'birthday', 'ore', 'date');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.email.add-search-config.unique",
-    "label": "Enable cipherstash search on users.email",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.email:add-search-config:unique@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash unique search config for users.email",
-        "sql": "SELECT eql_v2.add_search_config('users', 'email', 'unique', 'text');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.email.add-search-config.match",
-    "label": "Enable cipherstash search on users.email",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.email:add-search-config:match@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash match search config for users.email",
-        "sql": "SELECT eql_v2.add_search_config('users', 'email', 'match', 'text');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.email.add-search-config.ore",
-    "label": "Enable cipherstash search on users.email",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.email:add-search-config:ore@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash ore search config for users.email",
-        "sql": "SELECT eql_v2.add_search_config('users', 'email', 'ore', 'text');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.emailverified.add-search-config.unique",
-    "label": "Enable cipherstash search on users.emailverified",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.emailverified:add-search-config:unique@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash unique search config for users.emailverified",
-        "sql": "SELECT eql_v2.add_search_config('users', 'emailverified', 'unique', 'boolean');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.preferences.add-search-config.ste_vec",
-    "label": "Enable cipherstash search on users.preferences",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.preferences:add-search-config:ste_vec@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash ste_vec search config for users.preferences",
-        "sql": "SELECT eql_v2.add_search_config('users', 'preferences', 'ste_vec', 'jsonb');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.salary.add-search-config.unique",
-    "label": "Enable cipherstash search on users.salary",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.salary:add-search-config:unique@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash unique search config for users.salary",
-        "sql": "SELECT eql_v2.add_search_config('users', 'salary', 'unique', 'double');"
-      }
-    ],
-    "postcheck": []
-  },
-  {
-    "id": "cipherstash-codec.users.salary.add-search-config.ore",
-    "label": "Enable cipherstash search on users.salary",
-    "operationClass": "additive",
-    "invariantId": "cipherstash-codec:users.salary:add-search-config:ore@v1",
-    "target": {
-      "id": "postgres"
-    },
-    "precheck": [],
-    "execute": [
-      {
-        "description": "Register cipherstash ore search config for users.salary",
-        "sql": "SELECT eql_v2.add_search_config('users', 'salary', 'ore', 'double');"
-      }
-    ],
-    "postcheck": []
-  }
-]
\ No newline at end of file
diff --git a/examples/prisma/migrations/app/20260709T1034_initial/end-contract.d.ts b/examples/prisma/migrations/app/20260714T2142_initial/end-contract.d.ts
similarity index 71%
rename from examples/prisma/migrations/app/20260709T1034_initial/end-contract.d.ts
rename to examples/prisma/migrations/app/20260714T2142_initial/end-contract.d.ts
index d6c3d2b9..995e0f8c 100644
--- a/examples/prisma/migrations/app/20260709T1034_initial/end-contract.d.ts
+++ b/examples/prisma/migrations/app/20260714T2142_initial/end-contract.d.ts
@@ -40,7 +40,7 @@ import type {
 } from '@prisma-next/contract/types';
 
 export type StorageHash =
-  StorageHashBase<'sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa'>;
+  StorageHashBase<'sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720'>;
 export type ExecutionHash = ExecutionHashBase<string>;
 export type ProfileHash =
   ProfileHashBase<'sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb'>;
@@ -57,12 +57,12 @@ export type FieldOutputTypes = {
   readonly public: {
     readonly User: {
       readonly id: CodecTypes['pg/text@1']['output'];
-      readonly email: CodecTypes['cipherstash/string@1']['output'];
-      readonly salary: CodecTypes['cipherstash/double@1']['output'];
-      readonly accountId: CodecTypes['cipherstash/bigint@1']['output'];
-      readonly birthday: CodecTypes['cipherstash/date@1']['output'];
-      readonly emailVerified: CodecTypes['cipherstash/boolean@1']['output'];
-      readonly preferences: CodecTypes['cipherstash/json@1']['output'];
+      readonly email: CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['output'];
+      readonly salary: CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['output'];
+      readonly accountId: CodecTypes['cipherstash/eql-v3/eql_v3_bigint_ord@1']['output'];
+      readonly birthday: CodecTypes['cipherstash/eql-v3/eql_v3_date_ord@1']['output'];
+      readonly emailVerified: CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['output'];
+      readonly preferences: CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['output'];
     };
   };
 };
@@ -70,12 +70,12 @@ export type FieldInputTypes = {
   readonly public: {
     readonly User: {
       readonly id: CodecTypes['pg/text@1']['input'];
-      readonly email: CodecTypes['cipherstash/string@1']['input'];
-      readonly salary: CodecTypes['cipherstash/double@1']['input'];
-      readonly accountId: CodecTypes['cipherstash/bigint@1']['input'];
-      readonly birthday: CodecTypes['cipherstash/date@1']['input'];
-      readonly emailVerified: CodecTypes['cipherstash/boolean@1']['input'];
-      readonly preferences: CodecTypes['cipherstash/json@1']['input'];
+      readonly email: CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['input'];
+      readonly salary: CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['input'];
+      readonly accountId: CodecTypes['cipherstash/eql-v3/eql_v3_bigint_ord@1']['input'];
+      readonly birthday: CodecTypes['cipherstash/eql-v3/eql_v3_date_ord@1']['input'];
+      readonly emailVerified: CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['input'];
+      readonly preferences: CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['input'];
     };
   };
 };
@@ -102,44 +102,83 @@ type ContractBase = Omit<
                   readonly nullable: false;
                 };
                 readonly email: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/string@1';
+                  readonly nativeType: 'public.eql_v3_text_search';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_text_search@1';
                   readonly nullable: false;
                   readonly typeParams: {
-                    readonly equality: true;
-                    readonly freeTextSearch: true;
-                    readonly orderAndRange: true;
+                    readonly castAs: 'string';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: true;
+                    };
                   };
                 };
                 readonly salary: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/double@1';
+                  readonly nativeType: 'public.eql_v3_double_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'number';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly accountid: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/bigint@1';
+                  readonly nativeType: 'public.eql_v3_bigint_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'bigint';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly birthday: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/date@1';
+                  readonly nativeType: 'public.eql_v3_date_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'date';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly emailverified: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/boolean@1';
+                  readonly nativeType: 'public.eql_v3_boolean';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_boolean@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true };
+                  readonly typeParams: {
+                    readonly castAs: 'boolean';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly preferences: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/json@1';
+                  readonly nativeType: 'public.eql_v3_json';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_json@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly searchableJson: true };
+                  readonly typeParams: {
+                    readonly castAs: 'json';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                      readonly searchableJson: true;
+                    };
+                  };
                 };
               };
               primaryKey: { readonly columns: readonly ['id'] };
@@ -174,11 +213,14 @@ type ContractBase = Omit<
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/string@1';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_text_search@1';
                   readonly typeParams: {
-                    readonly equality: true;
-                    readonly freeTextSearch: true;
-                    readonly orderAndRange: true;
+                    readonly castAs: 'string';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: true;
+                    };
                   };
                 };
               };
@@ -186,40 +228,76 @@ type ContractBase = Omit<
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/double@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'number';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly accountId: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/bigint@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'bigint';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly birthday: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/date@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'date';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly emailVerified: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/boolean@1';
-                  readonly typeParams: { readonly equality: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_boolean@1';
+                  readonly typeParams: {
+                    readonly castAs: 'boolean';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly preferences: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/json@1';
-                  readonly typeParams: { readonly searchableJson: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_json@1';
+                  readonly typeParams: {
+                    readonly castAs: 'json';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                      readonly searchableJson: true;
+                    };
+                  };
                 };
               };
             };
diff --git a/examples/prisma/migrations/app/20260709T1034_initial/end-contract.json b/examples/prisma/migrations/app/20260714T2142_initial/end-contract.json
similarity index 79%
rename from examples/prisma/migrations/app/20260709T1034_initial/end-contract.json
rename to examples/prisma/migrations/app/20260714T2142_initial/end-contract.json
index 9a06c3eb..d49354db 100644
--- a/examples/prisma/migrations/app/20260709T1034_initial/end-contract.json
+++ b/examples/prisma/migrations/app/20260714T2142_initial/end-contract.json
@@ -18,44 +18,54 @@
               "accountId": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/bigint@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "bigint"
                   }
                 }
               },
               "birthday": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/date@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_date_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "date"
                   }
                 }
               },
               "email": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/string@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_text_search@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "freeTextSearch": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "freeTextSearch": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "string"
                   }
                 }
               },
               "emailVerified": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/boolean@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_boolean@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true
+                    "capabilities": {},
+                    "castAs": "boolean"
                   }
                 }
               },
@@ -69,21 +79,27 @@
               "preferences": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/json@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_json@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "searchableJson": true
+                    "capabilities": {
+                      "searchableJson": true
+                    },
+                    "castAs": "json"
                   }
                 }
               },
               "salary": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/double@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_double_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "number"
                   }
                 }
               }
@@ -129,39 +145,49 @@
             "users": {
               "columns": {
                 "accountid": {
-                  "codecId": "cipherstash/bigint@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord@1",
+                  "nativeType": "public.eql_v3_bigint_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "bigint"
                   }
                 },
                 "birthday": {
-                  "codecId": "cipherstash/date@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_date_ord@1",
+                  "nativeType": "public.eql_v3_date_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "date"
                   }
                 },
                 "email": {
-                  "codecId": "cipherstash/string@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_text_search@1",
+                  "nativeType": "public.eql_v3_text_search",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "freeTextSearch": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "freeTextSearch": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "string"
                   }
                 },
                 "emailverified": {
-                  "codecId": "cipherstash/boolean@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_boolean@1",
+                  "nativeType": "public.eql_v3_boolean",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true
+                    "capabilities": {},
+                    "castAs": "boolean"
                   }
                 },
                 "id": {
@@ -170,20 +196,26 @@
                   "nullable": false
                 },
                 "preferences": {
-                  "codecId": "cipherstash/json@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_json@1",
+                  "nativeType": "public.eql_v3_json",
                   "nullable": false,
                   "typeParams": {
-                    "searchableJson": true
+                    "capabilities": {
+                      "searchableJson": true
+                    },
+                    "castAs": "json"
                   }
                 },
                 "salary": {
-                  "codecId": "cipherstash/double@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_double_ord@1",
+                  "nativeType": "public.eql_v3_double_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "number"
                   }
                 }
               },
@@ -202,7 +234,7 @@
         "kind": "postgres-schema"
       }
     },
-    "storageHash": "sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa"
+    "storageHash": "sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720"
   },
   "capabilities": {
     "postgres": {
diff --git a/examples/prisma/migrations/app/20260714T2142_initial/migration.json b/examples/prisma/migrations/app/20260714T2142_initial/migration.json
new file mode 100644
index 00000000..0e594052
--- /dev/null
+++ b/examples/prisma/migrations/app/20260714T2142_initial/migration.json
@@ -0,0 +1,7 @@
+{
+  "from": null,
+  "to": "sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720",
+  "providedInvariants": [],
+  "createdAt": "2026-07-14T21:42:57.497Z",
+  "migrationHash": "sha256:e2e376a21c595db0754a1e59a7ce647822b1b4e342ba6fddc4403b8b333962ca"
+}
\ No newline at end of file
diff --git a/examples/prisma/migrations/app/20260714T2142_initial/migration.ts b/examples/prisma/migrations/app/20260714T2142_initial/migration.ts
new file mode 100755
index 00000000..7b992853
--- /dev/null
+++ b/examples/prisma/migrations/app/20260714T2142_initial/migration.ts
@@ -0,0 +1,95 @@
+#!/usr/bin/env -S node
+import {
+  col,
+  Migration,
+  MigrationCLI,
+  primaryKey,
+} from '@prisma-next/postgres/migration'
+
+export default class M extends Migration {
+  override describe() {
+    return {
+      from: null,
+      to: 'sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720',
+    }
+  }
+
+  override get operations() {
+    return [
+      this.createTable({
+        schema: 'public',
+        table: 'users',
+        columns: [
+          col('accountid', 'eql_v3_bigint_ord', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1',
+              typeParams: {
+                capabilities: { equality: true, orderAndRange: true },
+                castAs: 'bigint',
+              },
+            },
+          }),
+          col('birthday', 'eql_v3_date_ord', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1',
+              typeParams: {
+                capabilities: { equality: true, orderAndRange: true },
+                castAs: 'date',
+              },
+            },
+          }),
+          col('email', 'eql_v3_text_search', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_text_search@1',
+              typeParams: {
+                capabilities: {
+                  equality: true,
+                  freeTextSearch: true,
+                  orderAndRange: true,
+                },
+                castAs: 'string',
+              },
+            },
+          }),
+          col('emailverified', 'eql_v3_boolean', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_boolean@1',
+              typeParams: { capabilities: {}, castAs: 'boolean' },
+            },
+          }),
+          col('id', 'text', {
+            notNull: true,
+            codecRef: { codecId: 'pg/text@1' },
+          }),
+          col('preferences', 'eql_v3_json', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_json@1',
+              typeParams: {
+                capabilities: { searchableJson: true },
+                castAs: 'json',
+              },
+            },
+          }),
+          col('salary', 'eql_v3_double_ord', {
+            notNull: true,
+            codecRef: {
+              codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1',
+              typeParams: {
+                capabilities: { equality: true, orderAndRange: true },
+                castAs: 'number',
+              },
+            },
+          }),
+        ],
+        constraints: [primaryKey(['id'])],
+      }),
+    ]
+  }
+}
+
+MigrationCLI.run(import.meta.url, M)
diff --git a/examples/prisma/migrations/app/20260714T2142_initial/ops.json b/examples/prisma/migrations/app/20260714T2142_initial/ops.json
new file mode 100644
index 00000000..078f4091
--- /dev/null
+++ b/examples/prisma/migrations/app/20260714T2142_initial/ops.json
@@ -0,0 +1,41 @@
+[
+  {
+    "id": "table.users",
+    "label": "Create table \"users\"",
+    "summary": "Creates table \"users\"",
+    "operationClass": "additive",
+    "target": {
+      "id": "postgres",
+      "details": {
+        "schema": "public",
+        "objectType": "table",
+        "name": "users"
+      }
+    },
+    "precheck": [
+      {
+        "description": "ensure table \"users\" does not exist",
+        "sql": "SELECT (to_regclass($1)) IS NULL AS \"result\"",
+        "params": [
+          "\"public\".\"users\""
+        ]
+      }
+    ],
+    "execute": [
+      {
+        "description": "create table \"users\"",
+        "sql": "CREATE TABLE \"public\".\"users\" (\n  \"accountid\" eql_v3_bigint_ord NOT NULL,\n  \"birthday\" eql_v3_date_ord NOT NULL,\n  \"email\" eql_v3_text_search NOT NULL,\n  \"emailverified\" eql_v3_boolean NOT NULL,\n  \"id\" text NOT NULL,\n  \"preferences\" eql_v3_json NOT NULL,\n  \"salary\" eql_v3_double_ord NOT NULL,\n  PRIMARY KEY (\"id\")\n)",
+        "params": []
+      }
+    ],
+    "postcheck": [
+      {
+        "description": "verify table \"users\" exists",
+        "sql": "SELECT (to_regclass($1)) IS NOT NULL AS \"result\"",
+        "params": [
+          "\"public\".\"users\""
+        ]
+      }
+    ]
+  }
+]
\ No newline at end of file
diff --git a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json
new file mode 100644
index 00000000..c4a1bd9f
--- /dev/null
+++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json
@@ -0,0 +1,9 @@
+{
+  "from": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7",
+  "to": "sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7",
+  "providedInvariants": [
+    "cipherstash:install-eql-v3-bundle-v1"
+  ],
+  "createdAt": "2026-07-14T20:10:24.325Z",
+  "migrationHash": "sha256:d1ca5a987ab10eb85c2fe05700134b31f17f694d2d5b3df3969e902610b1d9cf"
+}
\ No newline at end of file
diff --git a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json
new file mode 100644
index 00000000..bf6e4398
--- /dev/null
+++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json
@@ -0,0 +1,32 @@
+[
+  {
+    "id": "cipherstash.install-eql-v3-bundle",
+    "label": "Install EQL v3 bundle (eql-3.0.0: public.eql_v3_* domains + eql_v3.* functions)",
+    "operationClass": "data",
+    "invariantId": "cipherstash:install-eql-v3-bundle-v1",
+    "target": {
+      "id": "postgres"
+    },
+    "precheck": [],
+    "execute": [
+      {
+        "description": "Install EQL v3 bundle (eql-3.0.0: public.eql_v3_* domains + eql_v3.* functions)",
+        "sql": "--! @file v3/schema.sql\n--! @brief EQL v3 schema creation\n--!\n--! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted\n--! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in\n--! public so application tables survive EQL schema uninstall. eql_v3 is the\n--! public API for index-term extractors, aggregates, AND the operator-backing\n--! comparison wrappers\n--! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment\n--! helpers). The wrappers are public because they are the function-form\n--! equivalent of every supported operator: platforms without operator support\n--! (Supabase/PostgREST calls functions, not operators) invoke them by name.\n--! eql_v3_internal houses INTERNAL implementation objects only: the\n--! searchable-encrypted-metadata (SEM) index-term types\n--! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support\n--! functions, the unsupported-operator blockers (which only raise), and the\n--! aggregate state functions. Together the two schemas are self-contained —\n--! they own every type they need and have no runtime dependency on another EQL\n--! schema.\n--!\n--! Drops existing schema if present to support clean reinstallation.\n--!\n--! @warning DROP SCHEMA CASCADE will remove all objects in the schema\n--! @note eql_v3 is a new, additional schema for the encrypted-domain families.\n--!\n--! @note DESIGN DECISION — EQL never grants permissions automatically. This\n--!       installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal:\n--!       access is strictly opt-in. A deployment that exposes EQL to\n--!       non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST)\n--!       must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on\n--!       the functions it needs. This is intentional least-privilege, not an\n--!       oversight — see docs/reference/permissions.md. eql_v3_internal is not\n--!       part of the public API and normally needs no grant; where a caller\n--!       reaches an internal object indirectly (a public operator/aggregate\n--!       whose backing state-fn/blocker lives there), grant it deliberately.\n\n--! @brief Drop existing EQL v3 schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3 CASCADE;\n\n--! @brief Create EQL v3 schema\n--! @note Houses the encrypted-domain type families\nCREATE SCHEMA eql_v3;\n\n--! @brief Drop existing EQL v3 internal schema\n--! @warning CASCADE will drop all dependent objects\nDROP SCHEMA IF EXISTS eql_v3_internal CASCADE;\n\n--! @brief Create EQL v3 internal implementation schema\n--! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their\n--!       support/constructor/comparator functions, the unsupported-operator\n--!       blockers (which only raise), the aggregate state functions, and the\n--!       SteVec CHECK validators. Kept out of the public `eql_v3` surface so\n--!       internal index-term TYPES do not clutter the Supabase Table Builder\n--!       type picker. NOTE: the operator-backing comparison *wrappers* are NOT\n--!       here — they are public in `eql_v3` so every operator has a callable\n--!       function equivalent for platforms without operator support.\nCREATE SCHEMA eql_v3_internal;\nCOMMENT ON SCHEMA eql_v3_internal IS\n  'EQL internal implementation detail; not a public API surface.';\n\n--! @brief Schemas owned by the eql_v3 surface\n--!\n--! Single source of truth for tooling that must enumerate every schema this\n--! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a\n--! future third eql_v3-family schema is one array literal to edit instead of\n--! a hardcoded schema-name predicate repeated at every call site. Keep in\n--! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in\n--! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into\n--! each schema; this drives what tooling scans across both.\n--!\n--! @return name[] The schema names eql_v3 owns (public + internal).\nCREATE FUNCTION eql_v3_internal.owned_schemas()\n  RETURNS name[]\n  LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$\n  SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[]\n$$;\n\n--! @file v3/crypto.sql\n--! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork)\n--!\n--! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency\n--! closure lives under src/v3/. Enables the pgcrypto extension which provides\n--! cryptographic functions used by the eql_v3 ORE comparison path.\n--!\n--! Installs pgcrypto into the `extensions` schema (Supabase convention) to\n--! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto\n--! has `pg_catalog, extensions, public` on its `search_path`, so a pre-existing\n--! install in `public` keeps working — and a pre-existing install anywhere else\n--! will be rejected at install time. The body is idempotent\n--! (`CREATE SCHEMA IF NOT EXISTS`, `pg_extension` guard), so running it\n--! alongside the eql_v2 copy in a combined install is safe.\n--!\n--! @note pgcrypto provides functions like digest(), hmac(), gen_random_bytes()\n\n--! @brief Create extensions schema (Supabase convention)\nCREATE SCHEMA IF NOT EXISTS extensions;\n\n--! @brief Enable pgcrypto extension and validate its schema\nDO $$\nDECLARE\n  pgcrypto_schema name;\nBEGIN\n  IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pgcrypto') THEN\n    CREATE EXTENSION pgcrypto WITH SCHEMA extensions;\n  END IF;\n\n  SELECT n.nspname INTO pgcrypto_schema\n  FROM pg_extension e\n  JOIN pg_namespace n ON n.oid = e.extnamespace\n  WHERE e.extname = 'pgcrypto';\n\n  IF pgcrypto_schema = 'extensions' THEN\n    -- expected location, nothing to say\n    NULL;\n  ELSIF pgcrypto_schema = 'public' THEN\n    RAISE NOTICE\n      'pgcrypto is installed in the `public` schema. EQL works against this layout, '\n      'but Supabase splinter will flag it as `extension_in_public`. Move it with: '\n      'ALTER EXTENSION pgcrypto SET SCHEMA extensions';\n  ELSE\n    RAISE EXCEPTION\n      'pgcrypto is installed in schema `%`, which is not on the EQL function search_path '\n      '(pg_catalog, extensions, public). EQL cryptographic operations would fail at '\n      'runtime. Relocate the extension before installing EQL: '\n      'ALTER EXTENSION pgcrypto SET SCHEMA extensions',\n      pgcrypto_schema;\n  END IF;\nEND $$;\n\n--! @file v3/common.sql\n--! @brief Common utility functions for the self-contained eql_v3 surface.\n--!\n--! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the\n--! one transitive helper it needs without reaching into another schema. The\n--! eql_v2 original is unchanged.\n\n--! @brief Convert JSONB hex array to bytea array\n--! @internal\n--!\n--! Converts a JSONB array of hex-encoded strings into a PostgreSQL bytea array.\n--! Used for deserializing binary data (like ORE terms) from JSONB storage.\n--!\n--! @param val jsonb JSONB array of hex-encoded strings\n--! @return bytea[] Array of decoded binary values\n--!\n--! @note Returns NULL if input is JSON null\n--! @note Each array element is hex-decoded to bytea\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). This helper's ONLY caller\n--!   chain is `ore_block_256(val)` -> `jsonb_array_to_ore_block_256(val)` —\n--!   both reached exclusively from plpgsql and btree operator-class support\n--!   contexts, where SQL functions can NEVER be inlined and instead pay the\n--!   per-call SQL-function executor (measured 3.5x the per-call cost of the\n--!   plpgsql equivalent; +43% on ORE ordered scans end-to-end). plpgsql\n--!   caches its plan across calls. The non-array guard preserves the v3\n--!   behaviour (returns NULL for a non-array scalar; the v2 plpgsql original\n--!   raised) — both callers only ever pass an array or JSON null (`val->'ob'`),\n--!   so the divergence stays unreachable in practice; JSON null and empty\n--!   array still return NULL exactly as before.\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb)\nRETURNS bytea[]\n  IMMUTABLE\nAS $$\nDECLARE\n  result bytea[];\nBEGIN\n  IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n    RETURN NULL;\n  END IF;\n  SELECT array_agg(decode(value::text, 'hex')::bytea)\n    INTO result\n  FROM jsonb_array_elements_text(val) AS value;\n  RETURN result;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS\n  'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n--! @file v3/sem/ore_block_256/types.sql\n--! @brief ORE block index-term types (eql_v3 SEM).\n--!\n--! Self-contained eql_v3 copies of the Order-Revealing Encryption block types\n--! (design D1/D3). The eql_v2 originals are unchanged.\n\n--! @brief ORE block term type for Order-Revealing Encryption\n--!\n--! Composite type representing a single ORE block term. Stores encrypted data\n--! as bytea that enables range comparisons without decryption.\nCREATE TYPE eql_v3_internal.ore_block_256_term AS (\n  bytes bytea\n);\n\n\n--! @brief ORE block index term type for range queries\n--!\n--! Composite type containing an array of ORE block terms. The array is stored\n--! in the 'ob' field of encrypted data payloads.\n--!\n--! @note Transient type used only during query execution.\nCREATE TYPE eql_v3_internal.ore_block_256 AS (\n  terms eql_v3_internal.ore_block_256_term[]\n);\n\n--! @file v3/sem/ore_block_256/functions.sql\n--! @brief ORE block construction, extraction, and comparison (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The\n--! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array\n--! and pgcrypto encrypt() are reached via the forked src/v3/common.sql and\n--! src/v3/crypto.sql so the whole closure stays under src/v3. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Convert JSONB array to ORE block composite type\n--! @internal\n--! @param val jsonb Array of hex-encoded ORE block terms\n--! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null\n--! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller\n--!   (`ore_block_256`) is itself plpgsql, so this function is NEVER reached\n--!   from an inlinable context — as `LANGUAGE sql` it paid the per-call\n--!   SQL-function executor on every compared value in the opclass hot path\n--!   (measured: +43% on ORE ordered scans vs the plpgsql form). The\n--!   non-array guard preserves the v3 behaviour (returns NULL for a\n--!   non-array scalar; the v2 plpgsql original raised); the caller only\n--!   reaches this when `has_ore_block_256(val)` is true, which requires\n--!   `val->'ob'` to be a JSON array, so that branch stays unreachable.\n--!   An empty array (`ob: []`, what encrypting the empty string `\"\"` produces)\n--!   yields a non-NULL composite with an EMPTY `terms` array — NOT NULL terms.\n--!   The `COALESCE` is load-bearing: `array_agg` over zero rows returns NULL, and\n--!   NULL terms make the comparator return NULL (so an empty-text row silently\n--!   drops out of ordered queries). An empty array instead engages the\n--!   comparator's `cardinality = 0` guard, which sorts empty BEFORE every\n--!   non-empty term. See issue #262 (pinned by T7).\nCREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb)\nRETURNS eql_v3_internal.ore_block_256\n  IMMUTABLE\nAS $$\nDECLARE\n  terms eql_v3_internal.ore_block_256_term[];\nBEGIN\n  IF val IS NULL OR jsonb_typeof(val) != 'array' THEN\n    RETURN NULL;\n  END IF;\n  SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term)\n    INTO terms\n  FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b;\n  -- plpgsql pitfall: `SELECT <composite> INTO <composite-var>` assigns the\n  -- select-list columns FIELD-WISE into the variable — return the row\n  -- constructor directly instead. The COALESCE stays load-bearing for the\n  -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and\n  -- the comparator needs an EMPTY terms array, not NULL terms.\n  RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @internal Keep the inline-critical marker so the post-install\n--! pin_search_path pass leaves this unpinned: a `SET search_path` clause on a\n--! plpgsql function forces per-call configuration switching — measurable on a\n--! helper invoked per compared value in the ore_block_256 opclass hot path.\n--! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the\n--! structural skip in tasks/pin_search_path_v3.sql does not recognise it;\n--! this marker is the documented manual opt-in.\nCOMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS\n  'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)';\n\n\n--! @brief Extract ORE block index term from JSONB payload\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ore_block_256 ORE block index term\n--! @throws Exception if 'ob' field is missing\nCREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb)\n  RETURNS eql_v3_internal.ore_block_256\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without\n    -- entering the body, so no explicit `val IS NULL` guard is needed.\n    IF eql_v3_internal.has_ore_block_256(val) THEN\n      RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob');\n    END IF;\n    RAISE 'Expected an ore index (ob) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Check if JSONB payload contains an ORE block index term\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True only if the 'ob' field is present and is a JSON array\n--! @note A well-formed ORE index term is always a JSON array of block terms, so\n--!   this guard treats a present-but-non-array `ob` (a scalar or object) as\n--!   absent. That makes the extractor `ore_block_256(val)` RAISE on a\n--!   structurally invalid `ob` payload at the boundary instead of silently\n--!   degrading it to a NULL index term in `jsonb_array_to_ore_block_256`. The\n--!   previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so\n--!   reported them as present. `{}` (absent `ob`) and `{\"ob\": null}` (JSON null)\n--!   both remain `false`.\nCREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN COALESCE(jsonb_typeof(val -> 'ob') = 'array', false);\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare two ORE block terms using cryptographic comparison\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term First ORE term\n--! @param b eql_v3_internal.ore_block_256_term Second ORE term\n--! @return integer -1 if a < b, 0 if a = b, 1 if a > b\n--! @throws Exception if ciphertexts are different lengths\n--! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)`\n--!   overloads all are). This deliberately diverges from the v2 originals,\n--!   which carry no volatility marker and so default to `VOLATILE`. The\n--!   comparison is deterministic — its only crypto call, pgcrypto `encrypt()`,\n--!   is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the\n--!   planner fold/cache these in ordering and index contexts. NOT `STRICT`:\n--!   the NULL-handling branches below are load-bearing for the array overload.\nCREATE 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)\n  RETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    eq boolean := true;\n    unequal_block smallint := 0;\n    hash_key bytea;\n    data_block bytea;\n    encrypt_block bytea;\n    target_block bytea;\n\n    left_block_size CONSTANT smallint := 16;\n    right_block_size CONSTANT smallint := 32;\n\n    -- Block count N is DERIVED from the ciphertext length, not hardcoded to 8.\n    -- Wire format per term:\n    --   [ N PRP bytes ][ N*16B left blocks ][ 16B hash key ][ N*32B right blocks ]\n    --   octet_length = 17*N + 16 + 32*N = 49*N + 16  =>  N = (octet_length - 16) / 49\n    -- This serves integer (N=8, 408B), timestamp (N=12, 604B), and numeric\n    -- (N=14, 702B) with one comparator.\n    n            integer;\n    left_offset  integer;  -- ordinal offset of the first left block (1 + N PRP bytes)\n    right_offset integer;  -- ordinal start of the right CT (= total left CT length = 17*N)\n\n    indicator smallint := 0;\n  BEGIN\n    IF a IS NULL AND b IS NULL THEN\n      RETURN 0;\n    END IF;\n\n    IF a IS NULL THEN\n      RETURN -1;\n    END IF;\n\n    IF b IS NULL THEN\n      RETURN 1;\n    END IF;\n\n    IF bit_length(a.bytes) != bit_length(b.bytes) THEN\n      RAISE EXCEPTION 'Ciphertexts are different lengths';\n    END IF;\n\n    -- Well-formedness: length must be exactly 49*N + 16 for some N >= 1. The\n    -- modulo alone is insufficient -- a 16-byte term passes (16 - 16) % 49 = 0\n    -- and derives N = 0, which would fall through to the all-blocks-equal path\n    -- and return 0 instead of raising. The `<= 16` clause is load-bearing.\n    IF octet_length(a.bytes) <= 16 OR (octet_length(a.bytes) - 16) % 49 != 0 THEN\n      RAISE EXCEPTION 'Malformed ORE term: % bytes', octet_length(a.bytes);\n    END IF;\n\n    n := (octet_length(a.bytes) - 16) / 49;\n    left_offset := 1 + n;     -- left blocks begin right after the N PRP bytes\n    right_offset := 17 * n;   -- right CT begins right after the 17*N-byte left CT\n\n    FOR block IN 0..n-1 LOOP\n      -- Compare each PRP byte (the first N bytes) and its 16-byte left block.\n      IF\n        substr(a.bytes, 1 + block, 1) != substr(b.bytes, 1 + block, 1)\n        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)\n      THEN\n        IF eq THEN\n          unequal_block := block;\n        END IF;\n        eq = false;\n      END IF;\n    END LOOP;\n\n    IF eq THEN\n      RETURN 0::integer;\n    END IF;\n\n    -- Hash key is the IV from the right CT of b.\n    hash_key := substr(b.bytes, right_offset + 1, 16);\n\n    -- First right block is at right_offset + nonce_size (ordinally indexed).\n    target_block := substr(b.bytes, right_offset + 17 + (unequal_block * right_block_size), right_block_size);\n\n    data_block := substr(a.bytes, left_offset + (left_block_size * unequal_block), left_block_size);\n\n    encrypt_block := encrypt(data_block::bytea, hash_key::bytea, 'aes-ecb');\n\n    indicator := (\n      get_bit(\n        encrypt_block,\n        0\n      ) + get_bit(target_block, get_byte(a.bytes, unequal_block))) % 2;\n\n    IF indicator = 1 THEN\n      RETURN 1::integer;\n    ELSE\n      RETURN -1::integer;\n    END IF;\n  END;\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare arrays of ORE block terms recursively\n--! @internal\n--! @param a eql_v3_internal.ore_block_256_term[] First array\n--! @param b eql_v3_internal.ore_block_256_term[] Second array\n--! @return integer -1/0/1, or NULL if either array is NULL\nCREATE 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[])\nRETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    cmp_result integer;\n  BEGIN\n    IF a IS NULL OR b IS NULL THEN\n      RETURN NULL;\n    END IF;\n\n    IF cardinality(a) = 0 AND cardinality(b) = 0 THEN\n      RETURN 0;\n    END IF;\n\n    IF (cardinality(a) = 0) AND cardinality(b) > 0 THEN\n      RETURN -1;\n    END IF;\n\n    IF cardinality(a) > 0 AND (cardinality(b) = 0) THEN\n      RETURN 1;\n    END IF;\n\n    cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]);\n\n    IF cmp_result = 0 THEN\n      RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]);\n    END IF;\n\n    RETURN cmp_result;\n  END\n$$ LANGUAGE plpgsql;\n\n\n--! @brief Compare ORE block composite types\n--! @internal\n--! @param a eql_v3_internal.ore_block_256 First ORE block\n--! @param b eql_v3_internal.ore_block_256 Second ORE block\n--! @return integer -1/0/1\nCREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS integer\n  IMMUTABLE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms);\n  END\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ope_cllw/types.sql\n--! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM)\n--!\n--! Domain type representing a CLLW (Copyless Logarithmic Width)\n--! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in\n--! the `op` field of encrypted scalar payloads (the `_ord_ope` domains); the\n--! domain carries the hex-decoded bytes.\n--!\n--! A DOMAIN over bytea, not a composite: the OPE ciphertext is\n--! order-preserving under plain byte comparison, so the domain inherits\n--! bytea's native comparison operators and DEFAULT btree operator class\n--! outright — no hand-written operators, comparator, or operator class (the\n--! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole\n--! comparison chain inlinable, so a functional btree index on\n--! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope`\n--! domains' comparison operators. Contrast eql_v3_internal.ore_cllw (`oc`), the SteVec\n--! CLLW-*ORE* composite compared by a custom per-byte protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ope_cllw\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\n\n--! @file v3/sem/hmac_256/types.sql\n--! @brief HMAC-SHA256 index term type (eql_v3 SEM)\n--!\n--! Domain type representing HMAC-SHA256 hash values. Used for exact-match\n--! encrypted searches. The hash is stored in the 'hm' field of encrypted data\n--! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is\n--! unchanged.\n--!\n--! @note Transient type used only during query execution.\nCREATE DOMAIN eql_v3_internal.hmac_256 AS text;\n\n--! @file v3/sem/bloom_filter/types.sql\n--! @brief Self-contained eql_v3 Bloom-filter SEM index-term type.\n\n--! @brief Bloom-filter index term: a bit array stored as smallint[].\n--!\n--! Backs the `match` capability (`@>` / `<@`) on `eql_v3_internal.text_match`. The\n--! filter is read from the `bf` field of an encrypted jsonb payload. Native\n--! `smallint[]` array-containment (`@>`/`<@`) is inherited through the domain,\n--! so this type needs no custom operators.\n--!\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/timestamp_types.sql\n--! @brief Encrypted-domain types for timestamp.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_timestamp.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)';\nEND\n$$;\n\n--! @file v3/scalars/functions.sql\n--! @brief Shared blocker helper for the eql_v3 encrypted-domain families.\n--!\n--! Per-domain wrapper functions live in src/v3/scalars/<T>/.\n--! Blockers in those files delegate to encrypted_domain_unsupported_bool\n--! so every domain raises a uniform domain-specific error rather than\n--! letting an unsupported operator fall through to native jsonb\n--! behaviour.\n\n--! @brief Shared blocker helper. Raises 'operator X is not supported\n--!        for TYPE' so unsupported domain operators surface a clear\n--!        error rather than fall through to native jsonb behaviour.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (=, <, @>, ->, etc.)\n--! @return boolean (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning jsonb. Identical to\n--!        encrypted_domain_unsupported_bool but typed for blockers shadowing\n--!        native operators whose result is jsonb (#>, -, #-, ||), so composed\n--!        expressions resolve and the body raises rather than failing earlier\n--!        with a misleading 'operator does not exist' on a boolean result.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (#>, -, #-, ||, etc.)\n--! @return jsonb (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Shared blocker helper returning text. Identical to\n--!        encrypted_domain_unsupported_bool but typed for blockers shadowing\n--!        the native #>> operator whose result is text.\n--! @param type_name Domain type name (eql_v3.<T>*)\n--! @param operator_name Operator symbol (#>>)\n--! @return text (never returns; always raises)\nCREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text)\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RAISE EXCEPTION 'operator % is not supported for %', operator_name, type_name;\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @file v3/sem/ore_block_256/operators.sql\n--! @brief Comparison operators on eql_v3_internal.ore_block_256.\n--!\n--! The six backing functions are inlinable single-statement SQL so the planner\n--! can fold the eql_v3 comparison wrappers through to functional-index matching.\n\n--! @brief Equality backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0\n$$;\n\n--! @brief Not-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the ORE blocks are not equal\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0\n$$;\n\n--! @brief Less-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1\n$$;\n\n--! @brief Less-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is less than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1\n$$;\n\n--! @brief Greater-than backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1\n$$;\n\n--! @brief Greater-than-or-equal backing function for ORE block types\n--! @internal\n--!\n--! @param a eql_v3_internal.ore_block_256 Left operand\n--! @param b eql_v3_internal.ore_block_256 Right operand\n--! @return boolean True if the left operand is greater than or equal to the right operand\n--!\n--! @see eql_v3_internal.compare_ore_block_256_terms\nCREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\nRETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1\n$$;\n\n\n--! @brief = operator for ORE block types\n--!\n--! COMMUTATOR is the operator itself: equality is symmetric. Required for the\n--! MERGES flag — without it the planner raises \"could not find commutator\" the\n--! first time an ore_block equality is used as a join qual (e.g. via the inlined\n--! eql_v3_internal.<T>_ord_ore equality wrappers).\nCREATE OPERATOR public.= (\n  FUNCTION=eql_v3_internal.ore_block_256_eq,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.=),\n  NEGATOR = OPERATOR(public.<>),\n  RESTRICT = eqsel,\n  JOIN = eqjoinsel,\n  HASHES,\n  MERGES\n);\n\n--! @brief <> operator for ORE block types\nCREATE OPERATOR public.<> (\n  FUNCTION=eql_v3_internal.ore_block_256_neq,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<>),\n  NEGATOR = OPERATOR(public.=),\n  RESTRICT = neqsel,\n  JOIN = neqjoinsel,\n  MERGES\n);\n\n--! @brief > operator for ORE block types\nCREATE OPERATOR public.> (\n  FUNCTION=eql_v3_internal.ore_block_256_gt,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<),\n  NEGATOR = OPERATOR(public.<=),\n  RESTRICT = scalargtsel,\n  JOIN = scalargtjoinsel\n);\n\n--! @brief < operator for ORE block types\nCREATE OPERATOR public.< (\n  FUNCTION=eql_v3_internal.ore_block_256_lt,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.>),\n  NEGATOR = OPERATOR(public.>=),\n  RESTRICT = scalarltsel,\n  JOIN = scalarltjoinsel\n);\n\n--! @brief <= operator for ORE block types\nCREATE OPERATOR public.<= (\n  FUNCTION=eql_v3_internal.ore_block_256_lte,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.>=),\n  NEGATOR = OPERATOR(public.>),\n  RESTRICT = scalarlesel,\n  JOIN = scalarlejoinsel\n);\n\n--! @brief >= operator for ORE block types\nCREATE OPERATOR public.>= (\n  FUNCTION=eql_v3_internal.ore_block_256_gte,\n  LEFTARG=eql_v3_internal.ore_block_256,\n  RIGHTARG=eql_v3_internal.ore_block_256,\n  COMMUTATOR = OPERATOR(public.<=),\n  NEGATOR = OPERATOR(public.<),\n  RESTRICT = scalargesel,\n  JOIN = scalargejoinsel\n);\n\n--! @file v3/sem/ope_cllw/functions.sql\n--! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM).\n\n--! @brief Extract CLLW OPE index term from JSONB payload\n--!\n--! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar\n--! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain.\n--!\n--! Inlinable single-statement SQL — the body is a strict expression of the\n--! argument (`->>` and `decode` are both STRICT), so the planner folds this\n--! into the calling query and functional btree indexes built on\n--! `eql_v3.ord_term(col)` (which calls this) engage structurally, the\n--! same way the hmac_256 equality chain does.\n--!\n--! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and\n--! the strict chain propagates it, so the extractor returns SQL NULL and\n--! btree's NULL handling filters those rows from range queries.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is\n--!         absent\nCREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb)\n  RETURNS eql_v3_internal.ope_cllw\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw\n$$;\n\nCOMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS\n  'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)';\n\n--! @file v3/sem/hmac_256/functions.sql\n--! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM).\n--!\n--! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and\n--! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar\n--! domains extract from the jsonb payload directly via a cast to the domain.\n--! (Doc comments deliberately avoid naming eql_v2 symbols so the\n--! self-containment grep stays clean.)\n\n--! @brief Extract HMAC-SHA256 index term from JSONB payload\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)`\n--! (which calls this) engage structurally.\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent\nCREATE FUNCTION eql_v3_internal.hmac_256(val jsonb)\n  RETURNS eql_v3_internal.hmac_256\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (val ->> 'hm')::eql_v3_internal.hmac_256\n$$;\n\n\n--! @brief Check if JSONB payload contains HMAC-SHA256 index term\n--!\n--! @param val jsonb containing encrypted EQL payload\n--! @return boolean True if 'hm' field is present and non-null\nCREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (val ->> 'hm') IS NOT NULL\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/text_types.sql\n--! @brief Encrypted-domain types for text.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_text.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_text_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_text_match.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_match AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'bf'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (containment)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_text_search_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND VALUE ? 'bf'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, containment)';\n\n  --! @brief Encrypted domain public.eql_v3_text_search.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_text_search AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE ? 'bf'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, containment)';\nEND\n$$;\n\n--! @file v3/sem/bloom_filter/functions.sql\n--! @brief Extractor for the eql_v3 Bloom-filter SEM index term.\n--!\n--! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column\n--! overloads are intentionally omitted — the eql_v3 scalar domains extract from\n--! the jsonb payload directly via a cast to the domain. (Doc comments\n--! deliberately avoid naming eql_v2 symbols so the self-containment grep stays\n--! clean.)\n\n--! @brief Test whether a jsonb payload carries a Bloom-filter (`bf`) term.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return boolean True when the `bf` key is present and non-null.\n--!\n--! @internal Defined for parity with the eql_v3 SEM index-term predicates\n--! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by\n--! the extractor below, which gates on value-shape inline, nor by the generated\n--! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept\n--! as the canonical presence test for callers that need one.\nCREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    RETURN val ? 'bf' AND val ->> 'bf' IS NOT NULL;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract the Bloom-filter index term from a jsonb payload.\n--!\n--! Inlinable single-statement SQL — the planner can fold this into the calling\n--! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which\n--! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE\n--! and no pinned `search_path`. Returns NULL when `bf` is absent or present but\n--! not a json array, rather than raising. The `text_match` domain CHECK\n--! guarantees the `bf` *key* is present but not that it is an array, so a\n--! non-array `bf` (e.g. `{\"bf\": null}`) can reach here even on a typed value;\n--! gating on `jsonb_typeof(...) = 'array'` returns NULL for that case — and for\n--! raw jsonb outside the domain — instead of erroring inside\n--! `jsonb_array_elements`. NULL, like the HMAC extractor, is the right answer. An\n--! empty `bf` array yields an empty filter (contains nothing, contained by\n--! everything), matching set-containment semantics.\n--!\n--! @param val jsonb The encrypted payload.\n--! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or\n--!   NULL when `bf` is absent or not a json array.\nCREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb)\n  RETURNS eql_v3_internal.bloom_filter\n  LANGUAGE sql\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array'\n    THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter\n  END\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/smallint_types.sql\n--! @brief Encrypted-domain types for smallint.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_smallint.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_smallint_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/real_types.sql\n--! @brief Encrypted-domain types for real.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_real.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_real_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_real_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/numeric_types.sql\n--! @brief Encrypted-domain types for numeric.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_numeric.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_numeric_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/integer_types.sql\n--! @brief Encrypted-domain types for integer.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_integer.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_integer_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/double_types.sql\n--! @brief Encrypted-domain types for double.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_double.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_double_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_double_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/date_types.sql\n--! @brief Encrypted-domain types for date.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_date.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_date_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_date_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/bigint_types.sql\n--! @brief Encrypted-domain types for bigint.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_bigint.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_eq.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'hm'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord_ore.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'ob'\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)';\n\n  --! @brief Encrypted domain public.eql_v3_bigint_ord_ope.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE ? 'op'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_ord.\n\n--! @brief Index extractor for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector text\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector integer\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/timestamp/query_timestamp_types.sql\n--! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_functions.sql\n--! @brief Functions for public.eql_v3_timestamp_eq.\n\n--! @brief Index extractor for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector text\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector integer\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_eq\n--! @return public.eql_v3_timestamp_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_search_ore.\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector text\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector integer\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_functions.sql\n--! @brief Functions for public.eql_v3_text_search.\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_search) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector text\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector text)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector integer\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_search, selector integer)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_search, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_search\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_search)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_search, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_search, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_search, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_search, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_search, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b public.eql_v3_text_search\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_search, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--! @param a jsonb\n--! @param b public.eql_v3_text_search\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_search)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector text\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_text_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector text\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_functions.sql\n--! @brief Functions for public.eql_v3_text_ord.\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector text\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector text)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector integer\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_ord, selector integer)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_text_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/text/query_text_types.sql\n--! @brief Query-operand domains for text (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_match AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'ob'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, containment)';\n\n  --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_text_search AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND VALUE ? 'op'\n        AND VALUE ? 'bf'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_functions.sql\n--! @brief Functions for public.eql_v3_text_match.\n\n--! @brief Index extractor for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b::public.eql_v3_text_match) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) <@ eql_v3.match_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector text\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector text)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector integer\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_match, selector integer)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_match\n--! @return public.eql_v3_text_match\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_match, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_match\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_match)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_match, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_match, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_match, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_match, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_match, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b public.eql_v3_text_match\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_match, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--! @param a jsonb\n--! @param b public.eql_v3_text_match\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_match)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_functions.sql\n--! @brief Functions for public.eql_v3_text_eq.\n\n--! @brief Index extractor for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector text\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector text)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector integer\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text_eq, selector integer)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_eq\n--! @return public.eql_v3_text_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_text_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_text_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector text\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector text\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_functions.sql\n--! @brief Functions for public.eql_v3_smallint_ord.\n\n--! @brief Index extractor for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector text\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector integer\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/smallint/query_smallint_types.sql\n--! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_functions.sql\n--! @brief Functions for public.eql_v3_smallint_eq.\n\n--! @brief Index extractor for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector text\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector integer\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_eq\n--! @return public.eql_v3_smallint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector text\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_real_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector text\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_functions.sql\n--! @brief Functions for public.eql_v3_real_ord.\n\n--! @brief Index extractor for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector text\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector text)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector integer\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_ord, selector integer)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_real_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/real/query_real_types.sql\n--! @brief Query-operand domains for real (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_functions.sql\n--! @brief Functions for public.eql_v3_real_eq.\n\n--! @brief Index extractor for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector text\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector text)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector integer\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real_eq, selector integer)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_eq\n--! @return public.eql_v3_real_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_real_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_real_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/numeric/query_numeric_types.sql\n--! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector text\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector text\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_numeric_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector text\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_functions.sql\n--! @brief Functions for public.eql_v3_numeric_eq.\n\n--! @brief Index extractor for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector text\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector integer\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_eq\n--! @return public.eql_v3_numeric_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/integer/query_integer_types.sql\n--! @brief Query-operand domains for integer (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector text\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord.\n\n--! @brief Index extractor for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector text\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector text)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector integer\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_integer_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector text\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_functions.sql\n--! @brief Functions for public.eql_v3_integer_eq.\n\n--! @brief Index extractor for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector text\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector text)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector integer\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_eq\n--! @return public.eql_v3_integer_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_integer_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/double/query_double_types.sql\n--! @brief Query-operand domains for double (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector text\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_functions.sql\n--! @brief Functions for public.eql_v3_double_ord.\n\n--! @brief Index extractor for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector text\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector text)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector integer\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord, selector integer)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_double_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector text\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_double_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_functions.sql\n--! @brief Functions for public.eql_v3_double_eq.\n\n--! @brief Index extractor for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector text\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector text)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector integer\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double_eq, selector integer)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_eq\n--! @return public.eql_v3_double_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_double_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_double_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/date/query_date_types.sql\n--! @brief Query-operand domains for date (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector text\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_functions.sql\n--! @brief Functions for public.eql_v3_date_ord.\n\n--! @brief Index extractor for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector text\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector text)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector integer\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord, selector integer)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_date_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector text\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_date_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_functions.sql\n--! @brief Functions for public.eql_v3_date_eq.\n\n--! @brief Index extractor for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector text\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector text)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector integer\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date_eq, selector integer)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_eq\n--! @return public.eql_v3_date_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_date_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_date_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/boolean/boolean_types.sql\n--! @brief Encrypted-domain types for boolean.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_boolean.\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_boolean AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'c'\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/bigint/query_bigint_types.sql\n--! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).\n--! @note Query-operand domains live in `eql_v3` (not `public`): they are\n--!       never valid column types, so they don't belong in the column-type\n--!       namespace, and dropping the EQL-owned schema can never drop an\n--!       application column.\n--! @note Cast a query operand explicitly to its `query_` domain in a predicate\n--!       (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,\n--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`\n--!       operator overloads and will not resolve.\n\nDO $$\nBEGIN\n  --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'hm'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'ob'\n        AND NOT (VALUE ? 'c')\n        AND jsonb_typeof(VALUE -> 'ob') = 'array'\n        AND jsonb_array_length(VALUE -> 'ob') > 0\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';\n\n  --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb\n      CHECK (\n        jsonb_typeof(VALUE) = 'object'\n        AND VALUE ? 'v'\n        AND VALUE ? 'i'\n        AND VALUE ? 'op'\n        AND NOT (VALUE ? 'c')\n        AND VALUE->>'v' = '3'\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ore.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector text\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ore, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ore\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ore)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ore, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ore, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ore, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ore)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector text\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql\n--! @brief Functions for public.eql_v3_bigint_ord_ope.\n\n--! @brief Index extractor for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector text\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector integer\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_ord_ope, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_ord_ope\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_ord_ope)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_ord_ope, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_ord_ope, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_ord_ope, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_ord_ope)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_functions.sql\n--! @brief Functions for public.eql_v3_bigint_eq.\n\n--! @brief Index extractor for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$;\n\n--! @brief Operator wrapper for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector text\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector integer\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_eq\n--! @return public.eql_v3_bigint_eq\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint_eq, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint_eq\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint_eq)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint_eq, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint_eq, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint_eq, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint_eq, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint_eq.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint_eq\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint_eq)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$\nLANGUAGE plpgsql;\n\n--! @file v3/jsonb/types.sql\n--! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! Three jsonb-backed domains (none over another domain — operators resolve\n--! against the ultimate base type jsonb, so the native-jsonb firewall in\n--! blockers.sql can attach):\n--!   - public.eql_v3_json     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_jsonb_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_jsonb  — a containment needle (sv elements, no ciphertext).\n\n--! @brief Validate a single SteVec entry payload.\n--! @internal\n--! @param val jsonb Candidate entry payload.\n--! @return boolean True when `val` is an sv entry with string `s`, string `c`,\n--!         and exactly one string deterministic term (`hm` XOR `op`).\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND jsonb_typeof(val -> 's') = 'string'\n     AND jsonb_typeof(val -> 'c') = 'string'\n     AND (\n       (jsonb_typeof(val -> 'hm') = 'string' AND NOT (val ? 'op'))\n       OR\n       (jsonb_typeof(val -> 'op') = 'string' AND NOT (val ? 'hm'))\n     ),\n    false\n  )\n$$;\n\n--! @brief Validate a SteVec containment query payload.\n--! @internal\n--! @param val jsonb Candidate query payload.\n--! @return boolean True when `val` is `{\"sv\":[...]}` and every element carries\n--!         string `s`, no ciphertext, and exactly one string term (`hm` XOR\n--!         `op`).\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_jsonb domain CHECK, where a SQL function can never be\n--!   inlined (and the CHECK itself cannot absorb this body — it needs a\n--!   subquery over the sv elements, which CHECK constraints forbid). plpgsql\n--!   caches its plan across calls instead of paying the per-call SQL-function\n--!   executor on every needle cast.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\nBEGIN\n  RETURN COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND NOT EXISTS (\n       SELECT 1\n       FROM jsonb_array_elements(\n         CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n       ) AS elem\n       WHERE NOT COALESCE((\n         jsonb_typeof(elem) = 'object'\n         AND jsonb_typeof(elem -> 's') = 'string'\n         AND NOT (elem ? 'c')\n         AND (\n           (jsonb_typeof(elem -> 'hm') = 'string' AND NOT (elem ? 'op'))\n           OR\n           (jsonb_typeof(elem -> 'op') = 'string' AND NOT (elem ? 'hm'))\n         )\n       ), false)\n     ),\n    false\n  );\nEND;\n$$;\n\n--! @brief Validate a root SteVec document payload.\n--! @internal\n--! @param val jsonb Candidate document payload.\n--! @return boolean True when `val` is an encrypted document envelope with\n--!         `v = 3`, `i`, an `sv` array, and valid sv entry elements.\nCREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT COALESCE(\n    jsonb_typeof(val) = 'object'\n     AND val ? 'v'\n     AND val ->> 'v' = '3'\n     AND val ? 'i'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND NOT EXISTS (\n       SELECT 1\n       FROM jsonb_array_elements(\n         CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END\n       ) AS elem\n       WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem)\n     ),\n    false\n  )\n$$;\n\n--! @brief Storage/root domain for an encrypted JSONB column.\n--!\n--! CHECK: a JSON object carrying the EQL envelope (`v = 3` version and `i` index\n--! metadata). Root `c` is intentionally NOT required — an sv-array root payload\n--! is `{i, v, sv}` with no root ciphertext. The CHECK now also requires an `sv`\n--! array, so the domain accepts only SteVec **document** payloads and rejects\n--! encrypted *scalar* payloads (which carry `c`/`hm`/`ob` but no `sv`) — this is\n--! what keeps `public.eql_v3_json` a typed document domain rather than a generic\n--! encrypted envelope. The firewall in blockers.sql attaches to this domain to\n--! stop native jsonb operators from reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"sv\":[...]}'::public.eql_v3_json`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json AS jsonb\n      CHECK (\n        public.eql_v3_is_valid_ste_vec_document_payload(VALUE)\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted JSONB document (containment, equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an individual sv element.\n--!\n--! A single element inside an `sv` array: a JSON object that carries a selector\n--! (`s`), a ciphertext (`c`), and **exactly one** of `hm` (HMAC-256, for\n--! hash-equality) or `op` (CLLW OPE, for ordered queries) — they are mutually\n--! exclusive. This is the type returned by `->` and accepted by the per-entry\n--! extractors `eql_v3.eq_term` / `eql_v3.ord_term`. Extra fields (`a`, root\n--! `i`/`v` merged in by `->`) are allowed.\n--!\n--! @see src/v3/jsonb/operators.sql\n--!\n--! @internal\n--! Implementation note (issue #354): the CHECK is an INLINE expression, not a\n--! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain\n--! constraints cannot inline SQL functions, so the function-call form paid\n--! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle\n--! cast in every field_eq query (+19% end-to-end vs v2, the entire measured\n--! regression on that scenario; see cipherstash/benches#23). The expression\n--! mirrors the validator body; the leading `VALUE IS NULL OR` preserves the\n--! validator's STRICT NULL-passes semantics (a bare COALESCE(..., false)\n--! would reject NULL, which `->` returns for a missing selector). Keep the\n--! two in sync — `jsonb_entry_check_matches_validator` in tests/sqlx pins\n--! the equivalence.\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_jsonb_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_jsonb_entry AS jsonb\n      CHECK (\n        VALUE IS NULL\n        OR COALESCE(\n          jsonb_typeof(VALUE) = 'object'\n           AND jsonb_typeof(VALUE -> 's') = 'string'\n           AND jsonb_typeof(VALUE -> 'c') = 'string'\n           AND (\n             (jsonb_typeof(VALUE -> 'hm') = 'string' AND NOT (VALUE ? 'op'))\n             OR\n             (jsonb_typeof(VALUE -> 'op') = 'string' AND NOT (VALUE ? 'hm'))\n           ),\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_jsonb_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)';\nEND\n$$;\n\n--! @brief Domain type for an STE-vec containment needle.\n--!\n--! A query-shaped payload `{\"sv\":[...]}` whose elements carry selector + index\n--! term but **never** a ciphertext (`c`). Each element must carry `s` and\n--! exactly one deterministic term (`hm` XOR `op`). Typing the needle this way\n--! stops selector-only needles from casting and matching every row via bare\n--! `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\",\"hm\":\"<hm>\"}]}'::eql_v3.query_jsonb`.\n--! @see eql_v3.to_ste_vec_query\n--!\n--! @internal\n--! Implementation note (issue #354): this CHECK CANNOT be inlined like\n--! public.eql_v3_jsonb_entry's — validating the sv elements requires a subquery\n--! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK\n--! constraints forbid subqueries. The validator is plpgsql instead (cached\n--! plan; substantially cheaper per call than a non-inlined LANGUAGE sql\n--! function — the same finding as issue #353), since this cast sits on the\n--! per-query hot path of every containment scenario\n--! (`$1::jsonb::eql_v3.query_jsonb`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_jsonb AS jsonb\n      CHECK (\n        public.eql_v3_is_valid_ste_vec_query_payload(VALUE)\n      );\n  END IF;\n\n  COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json to a query_jsonb needle.\n--!\n--! Normalises each sv element down to the matching-relevant fields: `s` plus\n--! exactly one of `hm` / `op`. Other fields (`c`, `a`, `i`/`v`, anything else)\n--! are stripped. This is the canonical needle shape for `@>` containment.\n--! Designed for use as a functional GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json Source encrypted payload\n--! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_jsonb\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json)\n  RETURNS eql_v3.query_jsonb\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(\n                jsonb_strip_nulls(\n                  jsonb_build_object(\n                    's',  elem -> 's',\n                    'hm', elem -> 'hm',\n                    'op', elem -> 'op'\n                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_jsonb\n$$;\n\nCREATE CAST (public.eql_v3_json AS eql_v3.query_jsonb)\n  WITH FUNCTION eql_v3.to_ste_vec_query\n  AS ASSIGNMENT;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_functions.sql\n--! @brief Functions for public.eql_v3_timestamp.\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector text\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector text)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector integer\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_timestamp, selector integer)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp\n--! @return public.eql_v3_timestamp\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_timestamp, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param selector public.eql_v3_timestamp\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_timestamp)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_timestamp, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_timestamp, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_timestamp, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_timestamp, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_timestamp, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b public.eql_v3_timestamp\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a public.eql_v3_timestamp\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_timestamp, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_timestamp.\n--! @param a jsonb\n--! @param b public.eql_v3_timestamp\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_timestamp)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a public.eql_v3_timestamp_ord_ore\n--! @param b eql_v3.query_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.\n--! @param a eql_v3.query_timestamp_ord_ore\n--! @param b public.eql_v3_timestamp_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a public.eql_v3_timestamp_ord\n--! @param b eql_v3.query_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord.\n--! @param a eql_v3.query_timestamp_ord\n--! @param b public.eql_v3_timestamp_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a public.eql_v3_timestamp_ord_ope\n--! @param b eql_v3.query_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.\n--! @param a eql_v3.query_timestamp_ord_ope\n--! @param b public.eql_v3_timestamp_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql\n--! @brief Functions for eql_v3.query_timestamp_eq.\n\n--! @brief Index extractor for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a public.eql_v3_timestamp_eq\n--! @param b eql_v3.query_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_timestamp_eq.\n--! @param a eql_v3.query_timestamp_eq\n--! @param b public.eql_v3_timestamp_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_search_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_operators.sql\n--! @brief Operators for public.eql_v3_text_search.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_text_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_operators.sql\n--! @brief Operators for public.eql_v3_text_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_functions.sql\n--! @brief Functions for public.eql_v3_text.\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector text\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector integer\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_text, selector integer)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param selector public.eql_v3_text\n--! @return public.eql_v3_text\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_text)\nRETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_text, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param selector public.eql_v3_text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_text, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_text, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_text, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_text, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_text, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b public.eql_v3_text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a public.eql_v3_text\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_text, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text.\n--! @param a jsonb\n--! @param b public.eql_v3_text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_search_ore.\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a public.eql_v3_text_search_ore\n--! @param b eql_v3.query_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search_ore.\n--! @param a eql_v3.query_text_search_ore\n--! @param b public.eql_v3_text_search_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_functions.sql\n--! @brief Functions for eql_v3.query_text_search.\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a public.eql_v3_text_search\n--! @param b eql_v3.query_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_search.\n--! @param a eql_v3.query_text_search\n--! @param b public.eql_v3_text_search\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a public.eql_v3_text_ord_ore\n--! @param b eql_v3.query_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ore.\n--! @param a eql_v3.query_text_ord_ore\n--! @param b public.eql_v3_text_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_functions.sql\n--! @brief Functions for eql_v3.query_text_ord.\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a public.eql_v3_text_ord\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_text_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Index extractor for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a public.eql_v3_text_ord_ope\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_ord_ope.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_functions.sql\n--! @brief Functions for eql_v3.query_text_match.\n\n--! @brief Index extractor for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @return eql_v3_internal.bloom_filter\nCREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)\nRETURNS eql_v3_internal.bloom_filter\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a public.eql_v3_text_match\n--! @param b eql_v3.query_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_match.\n--! @param a eql_v3.query_text_match\n--! @param b public.eql_v3_text_match\n--! @return boolean\nCREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_functions.sql\n--! @brief Functions for eql_v3.query_text_eq.\n\n--! @brief Index extractor for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a public.eql_v3_text_eq\n--! @param b eql_v3.query_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_text_eq.\n--! @param a eql_v3.query_text_eq\n--! @param b public.eql_v3_text_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_operators.sql\n--! @brief Operators for public.eql_v3_smallint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_functions.sql\n--! @brief Functions for public.eql_v3_smallint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector text\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector text)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector integer\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_smallint, selector integer)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint\n--! @return public.eql_v3_smallint\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_smallint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param selector public.eql_v3_smallint\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_smallint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_smallint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_smallint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_smallint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_smallint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_smallint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b public.eql_v3_smallint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a public.eql_v3_smallint\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_smallint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_smallint.\n--! @param a jsonb\n--! @param b public.eql_v3_smallint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_smallint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a public.eql_v3_smallint_ord_ore\n--! @param b eql_v3.query_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.\n--! @param a eql_v3.query_smallint_ord_ore\n--! @param b public.eql_v3_smallint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a public.eql_v3_smallint_ord\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_smallint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a public.eql_v3_smallint_ord_ope\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql\n--! @brief Functions for eql_v3.query_smallint_eq.\n\n--! @brief Index extractor for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a public.eql_v3_smallint_eq\n--! @param b eql_v3.query_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_smallint_eq.\n--! @param a eql_v3.query_smallint_eq\n--! @param b public.eql_v3_smallint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_real_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_operators.sql\n--! @brief Operators for public.eql_v3_real_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_functions.sql\n--! @brief Functions for public.eql_v3_real.\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector text\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector text)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector integer\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_real, selector integer)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param selector public.eql_v3_real\n--! @return public.eql_v3_real\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_real)\nRETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_real, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param selector public.eql_v3_real\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_real)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_real, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_real, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_real, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_real, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_real, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b public.eql_v3_real\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a public.eql_v3_real\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_real, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_real.\n--! @param a jsonb\n--! @param b public.eql_v3_real\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_real)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a public.eql_v3_real_ord_ore\n--! @param b eql_v3.query_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ore.\n--! @param a eql_v3.query_real_ord_ore\n--! @param b public.eql_v3_real_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_functions.sql\n--! @brief Functions for eql_v3.query_real_ord.\n\n--! @brief Index extractor for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a public.eql_v3_real_ord\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_real_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a public.eql_v3_real_ord_ope\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_ord_ope.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_functions.sql\n--! @brief Functions for eql_v3.query_real_eq.\n\n--! @brief Index extractor for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a public.eql_v3_real_eq\n--! @param b eql_v3.query_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_real_eq.\n--! @param a eql_v3.query_real_eq\n--! @param b public.eql_v3_real_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @file v3/sem/ore_block_256/operator_class.sql\n--! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256.\n--!\n--! Gives the composite type its DEFAULT btree opclass so the recommended\n--! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without\n--! an explicit opclass annotation (design D4).\n--!\n--! @note Creating an operator family/class requires superuser: Postgres forbids\n--!       CREATE OPERATOR FAMILY / CLASS to non-superusers to protect index\n--!       integrity. Managed platforms (Supabase, and most hosted Postgres) run\n--!       the installer as a non-superuser role, so the DO block below ATTEMPTS\n--!       the creation and skips it on insufficient_privilege (SQLSTATE 42501),\n--!       letting the single installer run everywhere. When the class is absent,\n--!       ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable,\n--!       but the order-preserving (OPE) ordering domains — whose extractor\n--!       return types carry a native btree opclass — still index without it. On\n--!       superuser installs (self-managed Postgres, the SQLx test matrix) the\n--!       class is created normally. Any non-privilege error still propagates.\n--! @see eql_v3_internal.compare_ore_block_256_terms\n\nDO $do$\nBEGIN\n  EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree';\n\n  EXECUTE $ddl$\n    CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class\n      DEFAULT FOR TYPE eql_v3_internal.ore_block_256\n      USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS\n        OPERATOR 1 public.<,\n        OPERATOR 2 public.<=,\n        OPERATOR 3 public.=,\n        OPERATOR 4 public.>=,\n        OPERATOR 5 public.>,\n        FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256)\n  $ddl$;\n\n  RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class';\nEXCEPTION\n  WHEN insufficient_privilege THEN\n    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';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a public.eql_v3_numeric_ord_ore\n--! @param b eql_v3.query_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.\n--! @param a eql_v3.query_numeric_ord_ore\n--! @param b public.eql_v3_numeric_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a public.eql_v3_numeric_ord\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_numeric_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a public.eql_v3_numeric_ord_ope\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql\n--! @brief Functions for eql_v3.query_numeric_eq.\n\n--! @brief Index extractor for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a public.eql_v3_numeric_eq\n--! @param b eql_v3.query_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_numeric_eq.\n--! @param a eql_v3.query_numeric_eq\n--! @param b public.eql_v3_numeric_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_operators.sql\n--! @brief Operators for public.eql_v3_numeric_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_functions.sql\n--! @brief Functions for public.eql_v3_numeric.\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector text\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector text)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector integer\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_numeric, selector integer)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric\n--! @return public.eql_v3_numeric\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_numeric, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param selector public.eql_v3_numeric\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_numeric)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_numeric, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_numeric, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_numeric, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_numeric, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_numeric, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b public.eql_v3_numeric\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a public.eql_v3_numeric\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_numeric, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_numeric.\n--! @param a jsonb\n--! @param b public.eql_v3_numeric\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_numeric)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a public.eql_v3_integer_ord_ore\n--! @param b eql_v3.query_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.\n--! @param a eql_v3.query_integer_ord_ore\n--! @param b public.eql_v3_integer_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord.\n\n--! @brief Index extractor for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a public.eql_v3_integer_ord\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_integer_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a public.eql_v3_integer_ord_ope\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_functions.sql\n--! @brief Functions for eql_v3.query_integer_eq.\n\n--! @brief Index extractor for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a public.eql_v3_integer_eq\n--! @param b eql_v3.query_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_integer_eq.\n--! @param a eql_v3.query_integer_eq\n--! @param b public.eql_v3_integer_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_operators.sql\n--! @brief Operators for public.eql_v3_integer_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_functions.sql\n--! @brief Functions for public.eql_v3_integer.\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector text\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector text)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector integer\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_integer, selector integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer\n--! @return public.eql_v3_integer\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_integer)\nRETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_integer, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param selector public.eql_v3_integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_integer, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_integer, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_integer, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_integer, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_integer, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b public.eql_v3_integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a public.eql_v3_integer\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_integer, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_integer.\n--! @param a jsonb\n--! @param b public.eql_v3_integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a public.eql_v3_double_ord_ore\n--! @param b eql_v3.query_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ore.\n--! @param a eql_v3.query_double_ord_ore\n--! @param b public.eql_v3_double_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_functions.sql\n--! @brief Functions for eql_v3.query_double_ord.\n\n--! @brief Index extractor for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a public.eql_v3_double_ord\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_double_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a public.eql_v3_double_ord_ope\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_ord_ope.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_functions.sql\n--! @brief Functions for eql_v3.query_double_eq.\n\n--! @brief Index extractor for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a public.eql_v3_double_eq\n--! @param b eql_v3.query_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_double_eq.\n--! @param a eql_v3.query_double_eq\n--! @param b public.eql_v3_double_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_double_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_operators.sql\n--! @brief Operators for public.eql_v3_double_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector text\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector text)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector integer\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_double, selector integer)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param selector public.eql_v3_double\n--! @return public.eql_v3_double\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_double)\nRETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_double, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param selector public.eql_v3_double\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_double)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_double, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_double, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_double, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_double, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_double, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b public.eql_v3_double\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a public.eql_v3_double\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_double, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--! @param a jsonb\n--! @param b public.eql_v3_double\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_double)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a public.eql_v3_date_ord_ore\n--! @param b eql_v3.query_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ore.\n--! @param a eql_v3.query_date_ord_ore\n--! @param b public.eql_v3_date_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_functions.sql\n--! @brief Functions for eql_v3.query_date_ord.\n\n--! @brief Index extractor for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a public.eql_v3_date_ord\n--! @param b eql_v3.query_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord.\n--! @param a eql_v3.query_date_ord\n--! @param b public.eql_v3_date_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_date_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a public.eql_v3_date_ord_ope\n--! @param b eql_v3.query_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_ord_ope.\n--! @param a eql_v3.query_date_ord_ope\n--! @param b public.eql_v3_date_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_functions.sql\n--! @brief Functions for eql_v3.query_date_eq.\n\n--! @brief Index extractor for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a public.eql_v3_date_eq\n--! @param b eql_v3.query_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_date_eq.\n--! @param a eql_v3.query_date_eq\n--! @param b public.eql_v3_date_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_date_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_operators.sql\n--! @brief Operators for public.eql_v3_date_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector text\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector text)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector integer\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_date, selector integer)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param selector public.eql_v3_date\n--! @return public.eql_v3_date\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_date)\nRETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_date, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param selector public.eql_v3_date\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_date)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_date, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_date, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_date, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_date, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_date, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b public.eql_v3_date\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a public.eql_v3_date\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_date, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--! @param a jsonb\n--! @param b public.eql_v3_date\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_date)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector text\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector text)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector integer\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_boolean, selector integer)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param selector public.eql_v3_boolean\n--! @return public.eql_v3_boolean\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_boolean, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param selector public.eql_v3_boolean\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_boolean)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_boolean, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_boolean, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_boolean, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_boolean, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_boolean, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b public.eql_v3_boolean\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a public.eql_v3_boolean\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_boolean, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--! @param a jsonb\n--! @param b public.eql_v3_boolean\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_boolean)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ore.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @return eql_v3_internal.ore_block_256\nCREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore)\nRETURNS eql_v3_internal.ore_block_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a public.eql_v3_bigint_ord_ore\n--! @param b eql_v3.query_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.\n--! @param a eql_v3.query_bigint_ord_ore\n--! @param b public.eql_v3_bigint_ord_ore\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a public.eql_v3_bigint_ord\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql\n--! @brief Functions for eql_v3.query_bigint_ord_ope.\n\n--! @brief Index extractor for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @return eql_v3_internal.ope_cllw\nCREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope)\nRETURNS eql_v3_internal.ope_cllw\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a public.eql_v3_bigint_ord_ope\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql\n--! @brief Functions for eql_v3.query_bigint_eq.\n\n--! @brief Index extractor for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @return eql_v3_internal.hmac_256\nCREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)\nRETURNS eql_v3_internal.hmac_256\nLANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a public.eql_v3_bigint_eq\n--! @param b eql_v3.query_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n\n--! @brief Operator wrapper for eql_v3.query_bigint_eq.\n--! @param a eql_v3.query_bigint_eq\n--! @param b public.eql_v3_bigint_eq\n--! @return boolean\nCREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_operators.sql\n--! @brief Operators for public.eql_v3_bigint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_functions.sql\n--! @brief Functions for public.eql_v3_bigint.\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector text\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector text)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector integer\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_bigint, selector integer)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint\n--! @return public.eql_v3_bigint\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector text\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param selector integer\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_bigint, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param selector public.eql_v3_bigint\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_bigint)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_bigint, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_bigint, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonpath\n--! @return boolean\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_bigint, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return text\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_bigint, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b integer\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b text[]\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_bigint, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b public.eql_v3_bigint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a public.eql_v3_bigint\n--! @param b jsonb\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_bigint, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_bigint.\n--! @param a jsonb\n--! @param b public.eql_v3_bigint\n--! @return jsonb\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_bigint)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$\nLANGUAGE plpgsql;\n\n--! @file v3/jsonb/functions.sql\n--! @brief Extractors, containment engine, and path/array functions for the\n--!        eql_v3 encrypted-JSONB (SteVec) surface.\n--!\n--! `selector` parameters here are *encrypted-side* selector hashes — the\n--! deterministic hash the crypto layer emits in the `s` field of each sv\n--! element. Plaintext JSONPaths are never accepted at runtime.\n\n------------------------------------------------------------------------------\n-- Envelope helpers (eql_v3 owns these; jsonb-only)\n------------------------------------------------------------------------------\n\n--! @brief Extract metadata (i, v) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i` and `v` fields.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_build_object('i', val->'i', 'v', val->'v');\n$$;\n\nCOMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS\n  'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)';\n\n--! @brief Extract ciphertext (c) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text Base64-encoded ciphertext.\n--! @throws Exception if `c` is absent.\nCREATE FUNCTION eql_v3.ciphertext(val jsonb)\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 'c' THEN\n      RETURN val->>'c';\n    END IF;\n    RAISE 'Expected a ciphertext (c) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Selector extractors\n------------------------------------------------------------------------------\n\n--! @brief Extract selector (s) from a raw jsonb encrypted value.\n--! @param val jsonb encrypted EQL payload\n--! @return text The selector value.\n--! @throws Exception if `s` is absent.\nCREATE FUNCTION eql_v3.selector(val jsonb)\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 's' THEN\n      RETURN val->>'s';\n    END IF;\n    RAISE 'Expected a selector index (s) value in json: %', val;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK\n--!        guarantees `s` is present, so this is a simple field access.\n--! @param entry public.eql_v3_jsonb_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_jsonb_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Equality-term extractor (XOR-aware: coalesce(hm, op))\n------------------------------------------------------------------------------\n\n--! @brief XOR-aware equality term extractor for public.eql_v3_jsonb_entry.\n--!\n--! Returns the bytea of whichever deterministic term the sv entry carries —\n--! `hm` (HMAC-256) or `op` (CLLW OPE). The two byte distributions are disjoint\n--! by construction, so byte equality on the coalesce is unambiguous. Canonical\n--! equality extractor used by `=` / `<>` on jsonb_entry.\n--!\n--! @param entry public.eql_v3_jsonb_entry\n--! @return bytea Decoded `hm` or `op` bytes (NULL if entry is NULL).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_jsonb_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(coalesce(entry ->> 'hm', entry ->> 'op'), 'hex')\n$$;\n\n------------------------------------------------------------------------------\n-- CLLW OPE per-entry overload (converged with the scalar ord_term)\n------------------------------------------------------------------------------\n\n--! @brief Extract the CLLW OPE index term from a ste_vec entry.\n--!\n--! An sv-element `op` term is only ever present on an sv element, never at a\n--! root encrypted value, so the typed overload accepts public.eql_v3_jsonb_entry —\n--! the jsonb_entry twin of the generated scalar `eql_v3.ord_term`\n--! extractors. Returns SQL NULL when `op` is absent (the strict `->>` /\n--! `decode` chain propagates it), so btree NULL-filters such rows from range\n--! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders\n--! under native byte comparison with the DEFAULT btree opclass, so a\n--! functional index on `eql_v3.ord_term(col -> 'selector')` engages\n--! structurally with no custom operator class (Supabase/managed-Postgres\n--! safe).\n--!\n--! @param entry public.eql_v3_jsonb_entry\n--! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when\n--!         `op` is absent.\nCREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_jsonb_entry)\n  RETURNS eql_v3_internal.ope_cllw\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3_internal.ope_cllw(entry::jsonb)\n$$;\n\n------------------------------------------------------------------------------\n-- sv-array helpers\n------------------------------------------------------------------------------\n\n--! @brief Extract the sv element array as raw jsonb[].\n--!\n--! Returns the elements of `sv` (or a single-element array wrapping the value\n--! when there is no `sv`). No envelope re-wrapping — raw jsonb elements.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of sv elements.\nCREATE FUNCTION eql_v3.ste_vec(val jsonb)\n  RETURNS jsonb[]\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb;\n    ary jsonb[];\n  BEGIN\n    IF val ? 'sv' THEN\n      sv := val->'sv';\n    ELSE\n      sv := jsonb_build_array(val);\n    END IF;\n\n    SELECT array_agg(elem)\n      INTO ary\n      FROM jsonb_array_elements(sv) AS elem;\n\n    RETURN ary;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Check if a jsonb payload is marked as an sv array (`a` flag true).\n--! @param val jsonb encrypted EQL payload\n--! @return boolean True if `a` is present and true.\nCREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  BEGIN\n    IF val ? 'a' THEN\n      RETURN (val->>'a')::boolean;\n    END IF;\n    RETURN false;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Deterministic-fields array for GIN containment\n------------------------------------------------------------------------------\n\n--! @brief Extract deterministic search fields (s, hm, op) per sv element.\n--!\n--! Excludes non-deterministic ciphertext so PostgreSQL's native jsonb `@>` can\n--! compare for containment. Use for GIN indexes and containment queries.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb[] Array of objects with only deterministic fields.\nCREATE FUNCTION eql_v3.jsonb_array(val jsonb)\nRETURNS jsonb[]\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT ARRAY(\n    SELECT jsonb_object_agg(kv.key, kv.value)\n    FROM jsonb_array_elements(\n      CASE WHEN val ? 'sv' THEN val->'sv' ELSE jsonb_build_array(val) END\n    ) AS elem,\n    LATERAL jsonb_each(elem) AS kv(key, value)\n    WHERE kv.key IN ('s', 'hm', 'op')\n    GROUP BY elem\n  );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS\n  'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Containment\n------------------------------------------------------------------------------\n\n--! @brief GIN-indexable containment check: does `a` contain all of `b`?\n--! @param a jsonb Container payload.\n--! @param b jsonb Search payload.\n--! @return boolean True if a contains all deterministic elements of b.\n--! @note Public raw-`jsonb[]` containment helper over the extracted\n--!       deterministic fields — the function-form entrypoint for containment on\n--!       platforms without operator support (Supabase/PostgREST). The typed\n--!       `public.eql_v3_json` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.ste_vec_contains` instead — but both agree on the result (a\n--!       parity test pins this). Also the documented GIN index expression\n--!       (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md.\nCREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS\n  'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)';\n\n--! @brief GIN-indexable \"is contained by\" check.\n--! @param a jsonb Payload to check.\n--! @param b jsonb Container payload.\n--! @return boolean True if all elements of a are contained in b.\n--! @note Public raw-`jsonb[]` reverse-containment helper — the function-form\n--!       entrypoint for `<@` on platforms without operator support. The typed\n--!       `public.eql_v3_json` `<@` operator binds to `eql_v3.ste_vec_contains` instead,\n--!       but both agree on the result.\nCREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb)\nRETURNS boolean\nIMMUTABLE STRICT PARALLEL SAFE\nLANGUAGE SQL\nAS $$\n  SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b);\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS\n  'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if an sv array contains a specific sv element.\n--!\n--! Match = selector equal AND eq_term equal (byte-equality over coalesce(hm,\n--! op)). This collapses the v2 hm/oc CASE: under the XOR contract both terms\n--! are deterministic and byte-disjoint, so either one is a valid equality\n--! discriminator and a single byte comparison is correct.\n--!\n--! ASSUMPTION (locked by a negative test in v3_jsonb_tests.rs): hm and op byte\n--! distributions never collide at a given selector. The crypto layer configures\n--! a selector for eq XOR ordered, so both sides of a real comparison carry the\n--! same term type — an hm needle never meets an op leaf at the same selector.\n--! This collapse would wrongly match an hm needle against an op leaf if their\n--! hex bytes were ever identical — which the contract prevents (an hm is a\n--! fixed 32-byte HMAC; an op is a CLLW OPE ciphertext whose length is a\n--! function of the plaintext bit width, never 32 bytes for the supported\n--! domains). The negative-containment test guards against regression.\n--!\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b is found in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    result boolean;\n    _a jsonb;\n  BEGIN\n    result := false;\n\n    FOR idx IN 1..array_length(a, 1) LOOP\n      _a := a[idx];\n      result := result OR (\n        eql_v3.selector(_a) = eql_v3.selector(b)\n        AND eql_v3.eq_term(_a::public.eql_v3_jsonb_entry) = eql_v3.eq_term(b::public.eql_v3_jsonb_entry)\n      );\n      EXIT WHEN result;\n    END LOOP;\n\n    RETURN result;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Does encrypted value `a` contain all sv elements of `b`?\n--!\n--! Empty b is always contained. Each element of b must match selector + eq_term\n--! in some element of a.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_json Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.ste_vec_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json, b public.eql_v3_json)\n  RETURNS boolean\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    result boolean;\n    sv_a jsonb[];\n    sv_b jsonb[];\n    _b jsonb;\n  BEGIN\n    sv_a := eql_v3.ste_vec(a);\n    sv_b := eql_v3.ste_vec(b);\n\n    IF array_length(sv_b, 1) IS NULL THEN\n      RETURN true;\n    END IF;\n\n    IF array_length(sv_a, 1) IS NULL THEN\n      RETURN false;\n    END IF;\n\n    result := true;\n\n    FOR idx IN 1..array_length(sv_b, 1) LOOP\n      _b := sv_b[idx];\n      result := result AND eql_v3.ste_vec_contains(sv_a, _b);\n    END LOOP;\n\n    RETURN result;\n  END;\n$$ LANGUAGE plpgsql;\n\n------------------------------------------------------------------------------\n-- Path queries (text selector only)\n------------------------------------------------------------------------------\n\n--! @brief Query encrypted JSONB for sv elements matching `selector`.\n--!\n--! Returns one jsonb_entry row per matching encrypted element. Returns empty\n--! set on no match. It deliberately does not wrap multiple matches as an\n--! public.eql_v3_json document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_jsonb_entry.\n--!\n--! @param val jsonb encrypted EQL payload with `sv`.\n--! @param selector text Selector hash (`s` value).\n--! @return SETOF public.eql_v3_jsonb_entry Matching encrypted entries.\n--! @see eql_v3.jsonb_path_query_first\nCREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text)\n  RETURNS SETOF public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry\n  FROM jsonb_array_elements(val -> 'sv') elem\n  WHERE elem ->> 's' = selector\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Check if a selector path exists in encrypted JSONB.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to test.\n--! @return boolean True if a matching element exists.\nCREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT EXISTS (\n    SELECT 1 FROM jsonb_array_elements(val -> 'sv') elem\n    WHERE elem ->> 's' = selector\n  );\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)';\n\n--! @brief Get the first sv element matching `selector`, or NULL.\n--! @param val jsonb encrypted EQL payload.\n--! @param selector text Selector hash to match.\n--! @return public.eql_v3_jsonb_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_jsonb_entry\n  FROM jsonb_array_elements(val -> 'sv') elem\n  WHERE elem ->> 's' = selector\n  LIMIT 1\n$$;\n\nCOMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS\n  'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)';\n\n------------------------------------------------------------------------------\n-- Array functions\n------------------------------------------------------------------------------\n\n--! @brief Get the length of an encrypted JSONB array.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return integer Number of elements.\n--! @throws Exception 'cannot get array length of a non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_length(val jsonb)\n  RETURNS integer\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n  BEGIN\n    IF eql_v3_internal.is_ste_vec_array(val) THEN\n      sv := eql_v3.ste_vec(val);\n      RETURN array_length(sv, 1);\n    END IF;\n\n    RAISE 'cannot get array length of a non-array';\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as rows.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF public.eql_v3_jsonb_entry One row per element (metadata preserved).\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb)\n  RETURNS SETOF public.eql_v3_jsonb_entry\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n    meta jsonb;\n    item jsonb;\n  BEGIN\n    IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n      RAISE 'cannot extract elements from non-array';\n    END IF;\n\n    meta := eql_v3.meta_data(val);\n    sv := eql_v3.ste_vec(val);\n\n    FOR idx IN 1..array_length(sv, 1) LOOP\n      item = sv[idx];\n      RETURN NEXT (meta || item)::public.eql_v3_jsonb_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n--! @brief Extract elements of an encrypted JSONB array as ciphertext text.\n--! @param val jsonb encrypted EQL payload (must have `a` flag true).\n--! @return SETOF text One ciphertext per element.\n--! @throws Exception 'cannot extract elements from non-array' if not an array.\nCREATE FUNCTION eql_v3.jsonb_array_elements_text(val jsonb)\n  RETURNS SETOF text\n  IMMUTABLE STRICT PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\n  DECLARE\n    sv jsonb[];\n  BEGIN\n    IF NOT eql_v3_internal.is_ste_vec_array(val) THEN\n      RAISE 'cannot extract elements from non-array';\n    END IF;\n\n    sv := eql_v3.ste_vec(val);\n\n    FOR idx IN 1..array_length(sv, 1) LOOP\n      RETURN NEXT eql_v3.ciphertext(sv[idx]);\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE\n-- Source is src/v3/version.template\n\nDROP FUNCTION IF EXISTS eql_v3.version();\n\n--! @file v3/version.sql\n--! @brief EQL version reporting (self-contained eql_v3 surface)\n--!\n--! This file is auto-generated from src/v3/version.template during build.\n--! The 3.0.0 placeholder is replaced with the actual release\n--! version (bare semver, e.g. \"3.0.0\") supplied via `mise run build --version`,\n--! or \"DEV\" for development builds.\n\n--! @brief Get the installed EQL version string\n--!\n--! Returns the version string for the installed EQL library. This value is\n--! baked in at build time from the release tag.\n--!\n--! @return text Version string (e.g. \"3.0.0\" or \"DEV\" for development builds)\n--!\n--! @note Auto-generated during build from src/v3/version.template\n--!\n--! Example: `SELECT eql_v3.version()` returns the installed version string,\n--! e.g. `'3.0.0'` (or `'DEV'` for development builds).\nCREATE FUNCTION eql_v3.version()\n  RETURNS text\n  IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT '3.0.0';\n$$ LANGUAGE SQL;\n\n--! @brief Schema-level version marker for obj_description() discoverability\n--!\n--! Mirrors eql_v3.version() as a comment on the schema so the installed\n--! version can also be read via obj_description('eql_v3'::regnamespace).\nCOMMENT ON SCHEMA eql_v3 IS '3.0.0';\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ore.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ore.\n--! @param state public.eql_v3_timestamp_ord_ore\n--! @param value public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore)\nRETURNS public.eql_v3_timestamp_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ore.\n--! @param input public.eql_v3_timestamp_ord_ore\n--! @return public.eql_v3_timestamp_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord_ope.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord_ope.\n--! @param state public.eql_v3_timestamp_ord_ope\n--! @param value public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope)\nRETURNS public.eql_v3_timestamp_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord_ope.\n--! @param input public.eql_v3_timestamp_ord_ope\n--! @return public.eql_v3_timestamp_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_timestamp_ord.\n\n--! @brief State function for min on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_timestamp_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_timestamp_ord.\n--! @param state public.eql_v3_timestamp_ord\n--! @param value public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord)\nRETURNS public.eql_v3_timestamp_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_timestamp_ord.\n--! @param input public.eql_v3_timestamp_ord\n--! @return public.eql_v3_timestamp_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_timestamp_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_operators.sql\n--! @brief Operators for public.eql_v3_timestamp.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/timestamp_eq_operators.sql\n--! @brief Operators for public.eql_v3_timestamp_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql\n--! @brief Operators for eql_v3.query_timestamp_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search_ore.\n\n--! @brief State function for min on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_search_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search_ore.\n--! @param state public.eql_v3_text_search_ore\n--! @param value public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore)\nRETURNS public.eql_v3_text_search_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search_ore.\n--! @param input public.eql_v3_text_search_ore\n--! @return public.eql_v3_text_search_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_search_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_search_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_search.\n\n--! @brief State function for min on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_search,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_search.\n--! @param state public.eql_v3_text_search\n--! @param value public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search)\nRETURNS public.eql_v3_text_search\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_search.\n--! @param input public.eql_v3_text_search\n--! @return public.eql_v3_text_search\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_search,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ore.\n\n--! @brief State function for min on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ore.\n--! @param state public.eql_v3_text_ord_ore\n--! @param value public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore)\nRETURNS public.eql_v3_text_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ore.\n--! @param input public.eql_v3_text_ord_ore\n--! @return public.eql_v3_text_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord_ope.\n\n--! @brief State function for min on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord_ope.\n--! @param state public.eql_v3_text_ord_ope\n--! @param value public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope)\nRETURNS public.eql_v3_text_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord_ope.\n--! @param input public.eql_v3_text_ord_ope\n--! @return public.eql_v3_text_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_text_ord.\n\n--! @brief State function for min on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_text_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_text_ord.\n--! @param state public.eql_v3_text_ord\n--! @param value public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord)\nRETURNS public.eql_v3_text_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_text_ord.\n--! @param input public.eql_v3_text_ord\n--! @return public.eql_v3_text_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_text_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_operators.sql\n--! @brief Operators for public.eql_v3_text.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_match_operators.sql\n--! @brief Operators for public.eql_v3_text_match.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/text_eq_operators.sql\n--! @brief Operators for public.eql_v3_text_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_search_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_search_operators.sql\n--! @brief Operators for eql_v3.query_text_search.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_operators.sql\n--! @brief Operators for eql_v3.query_text_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_text_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_match_operators.sql\n--! @brief Operators for eql_v3.query_text_match.\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3.contains,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3.contained_by,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/query_text_eq_operators.sql\n--! @brief Operators for eql_v3.query_text_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ore.\n--! @param state public.eql_v3_smallint_ord_ore\n--! @param value public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore)\nRETURNS public.eql_v3_smallint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ore.\n--! @param input public.eql_v3_smallint_ord_ore\n--! @return public.eql_v3_smallint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord_ope.\n--! @param state public.eql_v3_smallint_ord_ope\n--! @param value public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope)\nRETURNS public.eql_v3_smallint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord_ope.\n--! @param input public.eql_v3_smallint_ord_ope\n--! @return public.eql_v3_smallint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_smallint_ord.\n\n--! @brief State function for min on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_smallint_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_smallint_ord.\n--! @param state public.eql_v3_smallint_ord\n--! @param value public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord)\nRETURNS public.eql_v3_smallint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_smallint_ord.\n--! @param input public.eql_v3_smallint_ord\n--! @return public.eql_v3_smallint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_smallint_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_operators.sql\n--! @brief Operators for public.eql_v3_smallint.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/smallint_eq_operators.sql\n--! @brief Operators for public.eql_v3_smallint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_smallint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql\n--! @brief Operators for eql_v3.query_smallint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ore.\n\n--! @brief State function for min on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ore.\n--! @param state public.eql_v3_real_ord_ore\n--! @param value public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore)\nRETURNS public.eql_v3_real_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ore.\n--! @param input public.eql_v3_real_ord_ore\n--! @return public.eql_v3_real_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord_ope.\n\n--! @brief State function for min on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord_ope.\n--! @param state public.eql_v3_real_ord_ope\n--! @param value public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope)\nRETURNS public.eql_v3_real_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord_ope.\n--! @param input public.eql_v3_real_ord_ope\n--! @return public.eql_v3_real_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_real_ord.\n\n--! @brief State function for min on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_real_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_real_ord.\n--! @param state public.eql_v3_real_ord\n--! @param value public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord)\nRETURNS public.eql_v3_real_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_real_ord.\n--! @param input public.eql_v3_real_ord\n--! @return public.eql_v3_real_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_real_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_operators.sql\n--! @brief Operators for public.eql_v3_real.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/real_eq_operators.sql\n--! @brief Operators for public.eql_v3_real_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_operators.sql\n--! @brief Operators for eql_v3.query_real_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_real_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/real/query_real_eq_operators.sql\n--! @brief Operators for eql_v3.query_real_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent (CIP-3468).\n--!\n--! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql,\n--! which ATTEMPTS to create the default btree operator class for\n--! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege\n--! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud\n--! Supabase and most hosted Postgres — run the installer as a non-superuser\n--! role). When the class was created, this file is a no-op.\n--!\n--! When the class was skipped, the ORE-carrying domains would otherwise\n--! install half-working: `<`/`>` comparisons still run (as unindexable seq\n--! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare\n--! `ORDER BY` fail with opaque Postgres errors. Instead of that silent\n--! degradation, this file poisons every ORE-carrying domain (and its\n--! query-operand twin) with an always-raising CHECK constraint, so the first\n--! value coerced into the domain fails loudly and points at the\n--! platform-supported alternatives (OPE ordering / HMAC equality /\n--! bloom-filter match).\n--!\n--! Footguns honoured (see the encrypted-domain footgun list in CLAUDE.md):\n--! the poison function is LANGUAGE plpgsql (never inlined, so the RAISE\n--! cannot be planned away) and NOT STRICT (a STRICT function is skipped for\n--! NULL inputs, which would silently let NULLs through the poisoned domain).\n--!\n--! The poison constraints are added NOT VALID. For domains — unlike table\n--! constraints — this does not weaken enforcement: coercion applies every\n--! constraint regardless of validation status, so new casts and inserts\n--! (including NULL) still raise. What it skips is validating existing stored\n--! data: without it, re-running the installer over a database that already\n--! holds ORE values (written under an earlier superuser install, before the\n--! installing role was demoted) would run the always-raising poison against\n--! every stored row and abort the install.\n\nDO $do$\nBEGIN\n  IF EXISTS (\n    SELECT 1\n    FROM pg_catalog.pg_opclass c\n    JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod\n    WHERE am.amname = 'btree'\n      AND c.opcdefault\n      AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype\n  ) THEN\n    RETURN;\n  END IF;\n\n  --! @brief Poison CHECK backing for the ORE-carrying domains on platforms\n  --!        without the ORE operator class. Always raises; never returns.\n  --! @internal\n  CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\n  LANGUAGE plpgsql\n  AS $poison$\n  BEGIN\n    RAISE EXCEPTION 'EQL: % cannot be used on this platform: the EQL installer could not create the ORE operator class (requires superuser, unavailable on e.g. cloud-hosted Supabase)', domain_name\n      USING HINT = 'Use ' || alternatives || ' instead.',\n            ERRCODE = 'feature_not_supported';\n  END;\n  $poison$;\n  -- NOT VALID: skip validating existing stored data (rows written under an\n  -- earlier superuser install must stay readable, and re-installing over them\n  -- must not abort). Domain coercion still enforces the CHECK on every new\n  -- cast/insert regardless of validation status.\n\n  ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID;\n\n  ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable\n    CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID;\n\n  RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead';\nEND;\n$do$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_numeric_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql\n--! @brief Operators for eql_v3.query_numeric_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ore.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ore.\n--! @param state public.eql_v3_numeric_ord_ore\n--! @param value public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore)\nRETURNS public.eql_v3_numeric_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ore.\n--! @param input public.eql_v3_numeric_ord_ore\n--! @return public.eql_v3_numeric_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord_ope.\n\n--! @brief State function for min on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord_ope.\n--! @param state public.eql_v3_numeric_ord_ope\n--! @param value public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope)\nRETURNS public.eql_v3_numeric_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord_ope.\n--! @param input public.eql_v3_numeric_ord_ope\n--! @return public.eql_v3_numeric_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_numeric_ord.\n\n--! @brief State function for min on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_numeric_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_numeric_ord.\n--! @param state public.eql_v3_numeric_ord\n--! @param value public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord)\nRETURNS public.eql_v3_numeric_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_numeric_ord.\n--! @param input public.eql_v3_numeric_ord\n--! @return public.eql_v3_numeric_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_numeric_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_operators.sql\n--! @brief Operators for public.eql_v3_numeric.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/numeric/numeric_eq_operators.sql\n--! @brief Operators for public.eql_v3_numeric_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_integer_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/query_integer_eq_operators.sql\n--! @brief Operators for eql_v3.query_integer_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ore.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ore.\n--! @param state public.eql_v3_integer_ord_ore\n--! @param value public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore)\nRETURNS public.eql_v3_integer_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ore.\n--! @param input public.eql_v3_integer_ord_ore\n--! @return public.eql_v3_integer_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord_ope.\n\n--! @brief State function for min on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord_ope.\n--! @param state public.eql_v3_integer_ord_ope\n--! @param value public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope)\nRETURNS public.eql_v3_integer_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord_ope.\n--! @param input public.eql_v3_integer_ord_ope\n--! @return public.eql_v3_integer_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_integer_ord.\n\n--! @brief State function for min on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_integer_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_integer_ord.\n--! @param state public.eql_v3_integer_ord\n--! @param value public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord)\nRETURNS public.eql_v3_integer_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_integer_ord.\n--! @param input public.eql_v3_integer_ord\n--! @return public.eql_v3_integer_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_integer_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_operators.sql\n--! @brief Operators for public.eql_v3_integer.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/integer/integer_eq_operators.sql\n--! @brief Operators for public.eql_v3_integer_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_operators.sql\n--! @brief Operators for eql_v3.query_double_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_double_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/query_double_eq_operators.sql\n--! @brief Operators for eql_v3.query_double_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ore.\n\n--! @brief State function for min on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ore.\n--! @param state public.eql_v3_double_ord_ore\n--! @param value public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore)\nRETURNS public.eql_v3_double_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ore.\n--! @param input public.eql_v3_double_ord_ore\n--! @return public.eql_v3_double_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord_ope.\n\n--! @brief State function for min on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord_ope.\n--! @param state public.eql_v3_double_ord_ope\n--! @param value public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope)\nRETURNS public.eql_v3_double_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord_ope.\n--! @param input public.eql_v3_double_ord_ope\n--! @return public.eql_v3_double_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_double_ord.\n\n--! @brief State function for min on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_double_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_double_ord.\n--! @param state public.eql_v3_double_ord\n--! @param value public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord)\nRETURNS public.eql_v3_double_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_double_ord.\n--! @param input public.eql_v3_double_ord\n--! @return public.eql_v3_double_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_double_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_operators.sql\n--! @brief Operators for public.eql_v3_double.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/double/double_eq_operators.sql\n--! @brief Operators for public.eql_v3_double_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_operators.sql\n--! @brief Operators for eql_v3.query_date_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_date_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/query_date_eq_operators.sql\n--! @brief Operators for eql_v3.query_date_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ore.\n\n--! @brief State function for min on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ore.\n--! @param state public.eql_v3_date_ord_ore\n--! @param value public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore)\nRETURNS public.eql_v3_date_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ore.\n--! @param input public.eql_v3_date_ord_ore\n--! @return public.eql_v3_date_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord_ope.\n\n--! @brief State function for min on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord_ope.\n--! @param state public.eql_v3_date_ord_ope\n--! @param value public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope)\nRETURNS public.eql_v3_date_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord_ope.\n--! @param input public.eql_v3_date_ord_ope\n--! @return public.eql_v3_date_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_date_ord.\n\n--! @brief State function for min on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_date_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_date_ord.\n--! @param state public.eql_v3_date_ord\n--! @param value public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord)\nRETURNS public.eql_v3_date_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_date_ord.\n--! @param input public.eql_v3_date_ord\n--! @return public.eql_v3_date_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_date_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_operators.sql\n--! @brief Operators for public.eql_v3_date.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/date_eq_operators.sql\n--! @brief Operators for public.eql_v3_date_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/boolean/boolean_operators.sql\n--! @brief Operators for public.eql_v3_boolean.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ore.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql\n--! @brief Operators for eql_v3.query_bigint_ord_ope.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql\n--! @brief Operators for eql_v3.query_bigint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ore.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord_ore,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ore.\n--! @param state public.eql_v3_bigint_ord_ore\n--! @param value public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore)\nRETURNS public.eql_v3_bigint_ord_ore\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ore.\n--! @param input public.eql_v3_bigint_ord_ore\n--! @return public.eql_v3_bigint_ord_ore\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord_ore,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord_ope.\n\n--! @brief State function for min on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord_ope,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord_ope.\n--! @param state public.eql_v3_bigint_ord_ope\n--! @param value public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope)\nRETURNS public.eql_v3_bigint_ord_ope\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord_ope.\n--! @param input public.eql_v3_bigint_ord_ope\n--! @return public.eql_v3_bigint_ord_ope\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord_ope,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_ord_aggregates.sql\n--! @brief Aggregates for public.eql_v3_bigint_ord.\n\n--! @brief State function for min on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value < state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) (\n  sfunc = eql_v3_internal.min_sfunc,\n  stype = public.eql_v3_bigint_ord,\n  combinefunc = eql_v3_internal.min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_bigint_ord.\n--! @param state public.eql_v3_bigint_ord\n--! @param value public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord)\nRETURNS public.eql_v3_bigint_ord\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  IF value > state THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate for public.eql_v3_bigint_ord.\n--! @param input public.eql_v3_bigint_ord\n--! @return public.eql_v3_bigint_ord\nCREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) (\n  sfunc = eql_v3_internal.max_sfunc,\n  stype = public.eql_v3_bigint_ord,\n  combinefunc = eql_v3_internal.max_sfunc,\n  parallel = safe\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_operators.sql\n--! @brief Operators for public.eql_v3_bigint.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint\n);\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/bigint/bigint_eq_operators.sql\n--! @brief Operators for public.eql_v3_bigint_eq.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq,\n  COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq\n);\n\n--! @brief EQL lint: detect non-inlinable operator implementation functions\n--!\n--! Returns one row per violation found in the installed `eql_v3` surface. The\n--! Postgres planner can only inline a function during index matching when:\n--!\n--!   * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined)\n--!   * `IMMUTABLE` or `STABLE` volatility (VOLATILE cannot be inlined into\n--!     index expressions)\n--!   * No `SET` clauses (e.g. `SET search_path = ...`)\n--!   * Not `SECURITY DEFINER`\n--!   * Single-statement SELECT body\n--!\n--! @note The single-statement SELECT body condition is **not yet checked** by\n--! this lint. A `LANGUAGE sql` function with a multi-statement body, a CTE,\n--! or any pre-SELECT statement will pass all four implemented checks while\n--! remaining non-inlinable. Implementing the check requires walking `prosrc`\n--! (or `pg_get_functiondef`); tracked as a follow-up.\n--!\n--! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and\n--! the SEM index-term type `eql_v3_internal.ore_block_256`) whose\n--! implementation functions fail any of these rules silently fall back to seq\n--! scan when the documented functional indexes (`eql_v3.eq_term(col)`,\n--! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case.\n--!\n--! Severity:\n--!   `error`   — fixable, blocks index matching, ship-blocking.\n--!   `warning` — likely-fixable, may not block matching but signals intent.\n--!   `info`    — observational; useful for review, not a defect on its own.\n--!\n--! Categories:\n--!   `inlinability_language`   — implementation function isn't `LANGUAGE sql`.\n--!   `inlinability_volatility` — implementation function is VOLATILE.\n--!   `inlinability_set_clause` — implementation function has a `SET` clause.\n--!   `inlinability_secdef`     — implementation function is `SECURITY DEFINER`.\n--!   `inlinability_transitive` — implementation function is itself inlinable\n--!                                but its body invokes a non-inlinable function\n--!                                (depth 1; the planner can't peek through\n--!                                that boundary).\n--!   `blocker_language`        — encrypted-domain blocker is not LANGUAGE\n--!                                plpgsql. The planner can inline / elide a\n--!                                LANGUAGE sql body when the result is\n--!                                provably unused, silently bypassing the\n--!                                RAISE that the blocker exists to perform.\n--!   `blocker_strict`          — encrypted-domain blocker is STRICT.\n--!                                PostgreSQL skips the body and returns NULL\n--!                                on NULL arguments, silently bypassing the\n--!                                RAISE.\n--!   `domain_over_domain`      — an `eql_v3` encrypted domain is derived from\n--!                                another encrypted domain rather than jsonb.\n--!                                Operators resolve against the ultimate base\n--!                                type, so the derived domain does not\n--!                                inherit the base domain's blocker surface.\n--!   `domain_opclass`          — an operator class is declared FOR TYPE on an\n--!                                `eql_v3` encrypted domain. Opclasses on\n--!                                domains bypass operator resolution; use a\n--!                                functional index on the extractor instead.\n--!   `schema_placement`        — a naked composite or enum TYPE lives in the\n--!                                public `eql_v3` schema. Internal index-term\n--!                                types (e.g. `ore_block_256_term`) belong in\n--!                                `eql_v3_internal`; a composite/enum in\n--!                                `eql_v3` clutters the Supabase Table Builder\n--!                                type picker, which the schema split exists to\n--!                                prevent. Move it to `eql_v3_internal`.\n--!\n--! @example\n--! ```\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! ```\n--!\n--! @return SETOF record (severity text, category text, object_name text, message text)\nCREATE OR REPLACE FUNCTION eql_v3.lints()\nRETURNS TABLE (\n  severity text,\n  category text,\n  object_name text,\n  message text\n)\nLANGUAGE sql STABLE\nAS $$\n  WITH\n  -- User-column encrypted domains now live in public so application tables\n  -- survive EQL uninstall. Keep this separate from owned_schemas(): public is\n  -- not installer-owned, but its EQL jsonb-backed domains are still the domain\n  -- types whose blockers/operator surfaces the lint must understand.\n  encrypted_domain_types AS (\n    SELECT\n      dt.oid AS typid\n    FROM pg_catalog.pg_type dt\n    JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n    JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n    JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n    WHERE dt.typtype = 'd'\n      AND bt.typname = 'jsonb'\n      AND bn.nspname = 'pg_catalog'\n      AND (\n           dn.nspname = 'public'\n        OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n      )\n  ),\n\n  -- All operators where at least one operand is an EQL-owned type or a public\n  -- encrypted domain. Limits the scope of the lint to the operator surface\n  -- customers actually hit via SQL (`col = val`, `col @> '...'` and friends).\n  eql_operators AS (\n    SELECT\n      op.oid              AS oprid,\n      op.oprname          AS opname,\n      op.oprcode          AS implfunc,\n      op.oprleft::regtype AS lhs,\n      op.oprright::regtype AS rhs,\n      op.oprcode::regprocedure AS impl_signature\n    FROM pg_operator op\n    WHERE EXISTS (\n        SELECT 1 FROM pg_type t\n         WHERE t.oid IN (op.oprleft, op.oprright)\n           AND (\n                t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas()))\n             OR t.oid IN (SELECT typid FROM encrypted_domain_types)\n           )\n      )\n  ),\n\n  -- Cross-join with each operator's implementation function metadata.\n  -- One row per operator; columns describe the inlinability of the impl.\n  op_impl AS (\n    SELECT\n      eo.opname,\n      eo.lhs,\n      eo.rhs,\n      eo.implfunc                                  AS impl_oid,\n      eo.impl_signature::text                       AS impl_signature,\n      lang_l.lanname                                AS lang,\n      p.provolatile                                 AS volatility,\n      p.proconfig                                   AS config,\n      p.prosecdef                                   AS secdef,\n      p.prosrc                                      AS body\n    FROM eql_operators eo\n    JOIN pg_proc p ON p.oid = eo.implfunc\n    JOIN pg_language lang_l ON lang_l.oid = p.prolang\n  ),\n\n  -- Encrypted-domain blockers: functions in `eql_v3` whose body contains\n  -- a blocker marker emitted by the codegen (any of the\n  -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean\n  -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the\n  -- literal `is not supported for` for older path-operator blockers) AND\n  -- that take at least one encrypted domain over jsonb argument. The argument\n  -- filter excludes the shared `encrypted_domain_unsupported_*(text, text)`\n  -- helpers themselves, which contain the marker in their body but are not\n  -- blockers (they take text arguments, not a domain).\n  encrypted_domain_blockers AS (\n    SELECT\n      p.oid                                        AS oid,\n      p.oid::regprocedure::text                    AS signature,\n      lang_l.lanname                               AS lang,\n      p.proisstrict                                AS isstrict\n    FROM pg_catalog.pg_proc p\n    JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n    JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang\n    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n      AND (p.prosrc LIKE '%encrypted_domain_unsupported%'\n        OR p.prosrc LIKE '%is not supported for%')\n      AND EXISTS (\n        SELECT 1\n        FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n        JOIN encrypted_domain_types edt ON edt.typid = arg.typ\n      )\n  )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Direct inlinability checks: each row examines one operator's    │\n  -- │ implementation function and emits a violation if any rule is    │\n  -- │ broken. Multiple violations on the same function become         │\n  -- │ multiple rows (developers see every reason it doesn't inline).  │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  SELECT\n    'error'                                                             AS severity,\n    'inlinability_language'                                             AS category,\n    format('operator %s(%s, %s) -> %s',\n           opname, lhs, rhs, impl_signature)                            AS object_name,\n    format(\n      '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.',\n      lang, opname)                                                     AS message\n  FROM op_impl\n  WHERE lang <> 'sql'\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_volatility',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    format(\n      '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).',\n      opname)\n  FROM op_impl\n  WHERE volatility = 'v'\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_set_clause',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    format(\n      '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.')\n  FROM op_impl\n  WHERE config IS NOT NULL\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_secdef',\n    format('operator %s(%s, %s) -> %s', opname, lhs, rhs, impl_signature),\n    'Operator implementation function is `SECURITY DEFINER`. Such functions cannot be inlined; remove `SECURITY DEFINER` or use a non-inlinable wrapper layer.'\n  FROM op_impl\n  WHERE secdef\n    AND NOT EXISTS (\n      SELECT 1 FROM encrypted_domain_blockers b\n      WHERE b.oid = op_impl.impl_oid\n    )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Transitive inlinability: an operator implementation function    │\n  -- │ that's itself inlinable can still fail to inline if its body    │\n  -- │ calls a non-inlinable function. Walk one level via pg_depend.   │\n  -- │                                                                 │\n  -- │ Postgres records function-to-function dependencies in           │\n  -- │ pg_depend with deptype 'n' (normal) when one function references│\n  -- │ another in its body — but only at CREATE time and only for      │\n  -- │ direct calls. This is good enough for v1; deeper transitive     │\n  -- │ analysis is a follow-up.                                        │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'inlinability_transitive',\n    format('operator %s(%s, %s) -> %s', oi.opname, oi.lhs, oi.rhs,\n           oi.impl_signature),\n    format(\n      '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.',\n      called.proname,\n      called_lang.lanname,\n      CASE called.provolatile\n        WHEN 'i' THEN 'IMMUTABLE'\n        WHEN 's' THEN 'STABLE'\n        WHEN 'v' THEN 'VOLATILE'\n      END,\n      CASE WHEN called.proconfig IS NOT NULL\n           THEN ', has SET clause'\n           ELSE '' END)\n  FROM op_impl oi\n  -- Only worth the transitive check if the outer function is otherwise\n  -- inlinable — otherwise the direct lints above already report it.\n  JOIN pg_proc outer_p ON outer_p.oid = oi.impl_signature::regprocedure\n  JOIN pg_depend d\n    ON d.classid = 'pg_proc'::regclass\n   AND d.objid = outer_p.oid\n   AND d.refclassid = 'pg_proc'::regclass\n   AND d.deptype = 'n'\n  JOIN pg_proc called ON called.oid = d.refobjid\n  JOIN pg_language called_lang ON called_lang.oid = called.prolang\n  WHERE oi.lang = 'sql'\n    AND oi.volatility IN ('i', 's')\n    AND oi.config IS NULL\n    AND NOT oi.secdef\n    AND called.oid <> outer_p.oid\n    AND (\n         called_lang.lanname <> 'sql'\n      OR called.provolatile = 'v'\n      OR called.proconfig IS NOT NULL\n      OR called.prosecdef\n    )\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Encrypted-domain footguns: blockers exist to RAISE, so they     │\n  -- │ have inverted inlinability requirements vs operator impls.      │\n  -- │ A LANGUAGE sql blocker can be elided by the planner; a STRICT   │\n  -- │ blocker returns NULL on NULL args. Both silently re-enable      │\n  -- │ operators the storage variant is supposed to block.             │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'blocker_language',\n    format('function %s', signature),\n    format(\n      '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.',\n      lang)\n  FROM encrypted_domain_blockers\n  WHERE lang <> 'plpgsql'\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'blocker_strict',\n    format('function %s', signature),\n    'Encrypted-domain blocker is `STRICT`. PostgreSQL skips the body and returns NULL on a NULL argument, silently bypassing the RAISE. Remove `STRICT`.'\n  FROM encrypted_domain_blockers\n  WHERE isstrict\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Domain identity: an encrypted-domain must be defined directly   │\n  -- │ over jsonb. Operators resolve against the ultimate base type,   │\n  -- │ so domain-over-domain inherits jsonb's operator surface and not │\n  -- │ the base domain's blockers.                                     │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'domain_over_domain',\n    format('domain %I.%I', dn.nspname, dt.typname),\n    format(\n      '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.',\n      dn.nspname, dt.typname, bn.nspname, bt.typname)\n  FROM pg_catalog.pg_type dt\n  JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n  JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype\n  JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace\n  WHERE dt.typtype = 'd'\n    AND dn.nspname = ANY(eql_v3_internal.owned_schemas())\n    AND bt.typtype = 'd'\n    AND bt.oid IN (SELECT typid FROM encrypted_domain_types)\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Domain opclass: an operator class declared FOR TYPE on an       │\n  -- │ encrypted-domain bypasses operator resolution at index time.    │\n  -- │ Use a functional index on the extractor instead.                │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'domain_opclass',\n    format('opclass %I.%I FOR TYPE %s.%s', cn.nspname, oc.opcname, tn.nspname, t.typname),\n    format(\n      '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.',\n      cn.nspname, oc.opcname, tn.nspname, t.typname, tn.nspname, tn.nspname)\n  FROM pg_catalog.pg_opclass oc\n  JOIN pg_catalog.pg_type t ON t.oid = oc.opcintype\n  JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n  JOIN pg_catalog.pg_namespace cn ON cn.oid = oc.opcnamespace\n  WHERE t.oid IN (SELECT typid FROM encrypted_domain_types)\n\n  -- ┌─────────────────────────────────────────────────────────────────┐\n  -- │ Schema placement: the public `eql_v3` schema must hold only the  │\n  -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │\n  -- │ there is an internal index-term type in the wrong schema — it     │\n  -- │ clutters the Supabase type picker the split exists to keep clean. │\n  -- └─────────────────────────────────────────────────────────────────┘\n\n  UNION ALL\n\n  SELECT\n    'error',\n    'schema_placement',\n    format('type %I.%I', n.nspname, t.typname),\n    format(\n      '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      n.nspname, t.typname,\n      CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END)\n  FROM pg_catalog.pg_type t\n  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n  WHERE n.nspname = 'eql_v3'\n    AND t.typtype IN ('c', 'e')\n\n  ORDER BY 1, 2, 3;\n$$;\n\nCOMMENT ON FUNCTION eql_v3.lints() IS\n  'EQL lint: returns one row per non-inlinable operator implementation. '\n  'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a '\n  'CI-gateable check that all operator implementations on eql_v3 types are '\n  'eligible for planner inlining.';\n\n--! @file v3/jsonb/operators.sql\n--! @brief Operators on public.eql_v3_json and public.eql_v3_jsonb_entry.\n\n------------------------------------------------------------------------------\n-- -> field accessor (returns jsonb_entry)\n------------------------------------------------------------------------------\n\n--! @brief -> operator with text selector.\n--!\n--! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged\n--! in. Inlinable: `WHERE col -> 'sel' = $1` reduces structurally to\n--! `eql_v3.eq_term(col -> 'sel') = eql_v3.eq_term($1)` and matches a functional\n--! index on `eql_v3.eq_term(col -> 'sel')`.\n--!\n--! @warning The selector operand MUST carry a known type — a text-typed\n--!   parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`).\n--!   A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text`\n--!   operator and silently returns native jsonb semantics (a root-key lookup,\n--!   typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json`\n--!   domain to its base type `jsonb` when resolving an unknown-typed RHS, and the\n--!   native base-type operator wins the exact-match tiebreak. This is intrinsic to\n--!   the domain type-kind and applies to the native-jsonb blockers too. See\n--!   the \"Typed operands\" caveat in docs/reference/json-support.md.\n--!\n--! @param e public.eql_v3_json Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json, selector text)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (\n    eql_v3.meta_data(e) ||\n    jsonb_path_query_first(\n      e,\n      '$.sv[*] ? (@.s == $sel)'::jsonpath,\n      jsonb_build_object('sel', selector)\n    )\n  )::public.eql_v3_jsonb_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_jsonb_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json, selector integer)\n  RETURNS public.eql_v3_jsonb_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT CASE\n    WHEN eql_v3_internal.is_ste_vec_array(e) THEN\n      -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an\n      -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json, text)` operator does NOT capture a bare\n      -- untyped literal. The cast documents that intent and guards the `-> selector`\n      -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_jsonb_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- ->> field accessor (alias of -> coerced to text)\n------------------------------------------------------------------------------\n\n--! @brief ->> operator with text selector. Inlinable alias of -> coerced to\n--!        text.\n--!\n--! Intentional v2 parity: this serializes the entire matched jsonb_entry\n--! object as JSON text. It does not decrypt or return scalar plaintext like\n--! native `jsonb ->>`.\n--! @param e public.eql_v3_json Encrypted payload.\n--! @param selector text Field selector hash.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json, selector text)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n  FUNCTION=eql_v3.\"->>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=text\n);\n\n--! @brief ->> operator with integer array index. Inlinable alias of\n--!        ->(json, integer) coerced to text.\n--! @param e public.eql_v3_json Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return text The matching entry as text.\nCREATE FUNCTION eql_v3.\"->>\"(e public.eql_v3_json, selector integer)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"->\"(e, selector)::jsonb::text\n$$;\n\nCREATE OPERATOR ->> (\n  FUNCTION=eql_v3.\"->>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_json Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.ste_vec_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ste_vec_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief @> contains operator with an query_jsonb needle.\n--!\n--! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a\n--! functional GIN index on the same expression engages.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b eql_v3.query_jsonb Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b eql_v3.query_jsonb)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb @> b::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=eql_v3.query_jsonb\n);\n\n--! @brief @> contains operator with a single jsonb_entry needle.\n--!\n--! Wraps the entry into a single-element sv array (stripping `c`) and reduces\n--! to the same `to_ste_vec_query(a)::jsonb @> needle::jsonb` form.\n--!\n--! @param a public.eql_v3_json Container.\n--! @param b public.eql_v3_jsonb_entry Single entry.\n--! @return boolean True if a contains an sv entry matching b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json, b public.eql_v3_jsonb_entry)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> jsonb_build_object(\n            'sv',\n            jsonb_build_array(\n              jsonb_strip_nulls(\n                jsonb_build_object(\n                  's',  b -> 's',\n                  'hm', b -> 'hm',\n                  'op', b -> 'op'\n                )\n              )\n            )\n          )\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_jsonb_entry\n);\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json Contained value.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ste_vec_contains(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief <@ contained-by operator with an query_jsonb LHS.\n--! @param a eql_v3.query_jsonb Query payload.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_jsonb, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=eql_v3.query_jsonb,\n  RIGHTARG=public.eql_v3_json\n);\n\n--! @brief <@ contained-by operator with a jsonb_entry LHS.\n--! @param a public.eql_v3_jsonb_entry Single entry.\n--! @param b public.eql_v3_json Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_jsonb_entry, b public.eql_v3_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.\"@>\"(b, a)\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_jsonb_entry,\n  RIGHTARG=public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Equality on jsonb_entry via eq_term (hm-or-op byte equality).\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if the entries are equal\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b)\n$$;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = =,\n  NEGATOR  = <>,\n  RESTRICT = eqsel,\n  JOIN     = eqjoinsel\n);\n\n--! @brief Inequality on jsonb_entry via eq_term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if the entries are not equal\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b)\n$$;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <>,\n  NEGATOR  = =,\n  RESTRICT = neqsel,\n  JOIN     = neqjoinsel\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = >,\n  NEGATOR  = >=,\n  RESTRICT = scalarltsel,\n  JOIN     = scalarltjoinsel\n);\n\n--! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is less than or equal to b\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = >=,\n  NEGATOR  = >,\n  RESTRICT = scalarlesel,\n  JOIN     = scalarlejoinsel\n);\n\n--! @brief Greater-than on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <,\n  NEGATOR  = <=,\n  RESTRICT = scalargtsel,\n  JOIN     = scalargtjoinsel\n);\n\n--! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term.\n--! @param a public.eql_v3_jsonb_entry Left operand\n--! @param b public.eql_v3_jsonb_entry Right operand\n--! @return boolean True if a is greater than or equal to b\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_jsonb_entry, b public.eql_v3_jsonb_entry)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b)\n$$;\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG  = public.eql_v3_jsonb_entry,\n  RIGHTARG = public.eql_v3_jsonb_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\n\n--! @file v3/jsonb/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json.\n--!\n--! public.eql_v3_json SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! = <> < <= > >= are supported on public.eql_v3_jsonb_entry only, not on the root\n--! document domain.\n--! Every OTHER native jsonb operator reachable via domain fallback against the\n--! base type jsonb is BLOCKED here so an encrypted column can never silently\n--! route to plaintext-jsonb semantics. The blocked set is KNOWN_JSONB_OPERATORS\n--! minus the supported ops: ? ?| ?& @? @@ #> #>> - #- ||.\n--!\n--! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let\n--! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the\n--! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_*\n--! helpers. Each blocker's RETURNS type matches the native operator it shadows\n--! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a\n--! composed expression resolves and the body raises 'operator not supported',\n--! rather than failing earlier with a misleading 'operator does not exist' on a\n--! boolean intermediate. The bound operator must resolve before native fallback,\n--! so the firewall fires.\n\n--! @brief Blocker: ? (key/element exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json, b text)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json, b text[])\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonpath Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json, b jsonpath)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return text Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json, b text[])\nRETURNS text\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json, b text)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b integer Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json, b integer)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b text[] Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json, b text[])\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json, b jsonb)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the right).\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return jsonb Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json)\nRETURNS jsonb\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json document comparisons.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json-to-jsonb comparisons.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n------------------------------------------------------------------------------\n-- Mixed jsonb containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: @> with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: @> with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json Left operand (encrypted payload).\n--! @param b jsonb Native RHS operand.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json, b jsonb)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with native jsonb and encrypted root document.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json Right operand (encrypted payload).\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json)\nRETURNS boolean\nIMMUTABLE PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json,\n  RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json,\n  LEFTARG = jsonb,\n  RIGHTARG = public.eql_v3_json\n);\n\n--! @file v3/jsonb/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_jsonb_entry.\n--!\n--! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by\n--! their CLLW OPE (`op`) term, so the extremum is picked by comparing\n--! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the\n--! generated scalar ord aggregates use. The ope_cllw bytea domain orders under\n--! native byte comparison, so `<` / `>` on the extracted terms needs no custom\n--! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar\n--! `min`/`max` so partial/parallel aggregation is available on large GROUP BY\n--! workloads.\n--!\n--! Per the encrypted-domain footgun rules the state functions are\n--! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would\n--! be inlinable and the planner could elide it.\n--!\n--! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)`\n--!   returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a\n--!   `eql_v3.ord_term` btree NULL-filters from range scans. The state functions\n--!   therefore IGNORE `op`-less entries (they never become or survive as the\n--!   extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and\n--!   `op`-less entries and is not corrupted by an `op`-less seed. A naive\n--!   `ord_term(value) < ord_term(state)` would be NULL whenever either side\n--!   lacks `op`, pinning a wrong (`op`-less) extremum when the first aggregated\n--!   row is `op`-less. An all-`op`-less input has no orderable extremum and\n--!   returns the (arbitrary) STRICT seed.\n\n--! @brief State function for min on public.eql_v3_jsonb_entry.\n--!\n--! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL\n--! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable)\n--! entries are skipped explicitly (see the @note on this file).\n--!\n--! @param state public.eql_v3_jsonb_entry Running extremum.\n--! @param value public.eql_v3_jsonb_entry Candidate entry.\n--! @return public.eql_v3_jsonb_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_jsonb_entry,\n  value public.eql_v3_jsonb_entry\n)\nRETURNS public.eql_v3_jsonb_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n  -- A non-orderable (op-less) candidate never replaces the running extremum.\n  IF value_ope IS NULL THEN\n    RETURN state;\n  END IF;\n  -- Adopt the candidate when the running extremum is itself non-orderable\n  -- (e.g. an op-less STRICT seed) or strictly greater.\n  IF state_ope IS NULL OR value_ope < state_ope THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief min aggregate over public.eql_v3_jsonb_entry.\n--! @param input public.eql_v3_jsonb_entry\n--! @return public.eql_v3_jsonb_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_jsonb_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_jsonb_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  parallel = safe\n);\n\n--! @brief State function for max on public.eql_v3_jsonb_entry.\n--!\n--! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less\n--! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note).\n--!\n--! @param state public.eql_v3_jsonb_entry Running extremum.\n--! @param value public.eql_v3_jsonb_entry Candidate entry.\n--! @return public.eql_v3_jsonb_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_jsonb_entry,\n  value public.eql_v3_jsonb_entry\n)\nRETURNS public.eql_v3_jsonb_entry\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nDECLARE\n  value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value);\n  state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state);\nBEGIN\n  -- A non-orderable (op-less) candidate never replaces the running extremum.\n  IF value_ope IS NULL THEN\n    RETURN state;\n  END IF;\n  -- Adopt the candidate when the running extremum is itself non-orderable\n  -- (e.g. an op-less STRICT seed) or strictly lesser.\n  IF state_ope IS NULL OR value_ope > state_ope THEN\n    RETURN value;\n  END IF;\n  RETURN state;\nEND;\n$$;\n\n--! @brief max aggregate over public.eql_v3_jsonb_entry.\n--! @param input public.eql_v3_jsonb_entry\n--! @return public.eql_v3_jsonb_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_jsonb_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_jsonb_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n--! @file pin_search_path_v3.sql\n--! @brief Post-install: pin search_path on every eql_v3.* function.\n--!\n--! Appended verbatim by `tasks/build.sh` to the end of the v3-only release\n--! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives\n--! outside src/ so it stays out of the dependency graph.\n--!\n--! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and\n--! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`,\n--! satisfying Supabase splinter's `function_search_path_mutable` lint.\n--!\n--! @note A SET clause disables SQL-function inlining. The inline-critical SEM\n--!       helpers (ore_block_256_*, ope_cllw, hmac_256, bloom_filter over\n--!       jsonb) and the encrypted-domain family (recognised structurally,\n--!       including public user-column domains) are deliberately left\n--!       unpinned.\n--! @see tasks/test/splinter.sh\n--! @see tasks/build.sh\n\nDO $$\nDECLARE\n  fn_oid oid;\n  inline_critical_oids oid[];\n  jsonb_oid oid;\nBEGIN\n  SELECT t.oid INTO jsonb_oid\n  FROM pg_catalog.pg_type t\n  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n  WHERE n.nspname = 'pg_catalog' AND t.typname = 'jsonb';\n\n  IF jsonb_oid IS NULL THEN\n    RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found';\n  END IF;\n\n  -- eql_v3 SEM index-term functions that must stay inlinable for\n  -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause\n  -- in the legacy combined pin_search_path.sql.\n  SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids\n  FROM pg_catalog.pg_proc p\n  JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n  WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n    AND (\n      (p.pronargs = 2\n        AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq',\n                          'ore_block_256_lt', 'ore_block_256_lte',\n                          'ore_block_256_gt', 'ore_block_256_gte'))\n      -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a\n      -- domain over bytea (native comparison operators and btree opclass),\n      -- so there are no ope-specific comparison functions to keep inlinable.\n      OR (p.pronargs = 1\n        AND p.proname = 'ope_cllw'\n        AND p.proargtypes[0] = jsonb_oid)\n      OR (p.pronargs = 1\n        AND p.proname = 'hmac_256'\n        AND p.proargtypes[0] = jsonb_oid)\n      OR (p.pronargs = 1\n        AND p.proname = 'bloom_filter'\n        AND p.proargtypes[0] = jsonb_oid)\n    );\n\n  FOR fn_oid IN\n    SELECT p.oid\n    FROM pg_catalog.pg_proc p\n    JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n    WHERE n.nspname = ANY(eql_v3_internal.owned_schemas())\n      AND p.prokind IN ('f', 'w')\n      AND NOT EXISTS (\n        SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c\n        WHERE c LIKE 'search_path=%'\n      )\n      AND NOT (p.oid = ANY (coalesce(inline_critical_oids, '{}'::oid[])))\n      -- Encrypted-domain family — structural skip: LANGUAGE sql, IMMUTABLE,\n      -- taking >=1 argument typed as a jsonb-backed DOMAIN. User-column\n      -- domains live in public; implementation-only domains live in EQL-owned\n      -- schemas.\n      AND NOT (\n        p.prolang = (SELECT l.oid FROM pg_catalog.pg_language l\n                     WHERE l.lanname = 'sql')\n        AND p.provolatile = 'i'\n        AND EXISTS (\n          SELECT 1\n          FROM pg_catalog.unnest(p.proargtypes::oid[]) AS arg(typ)\n          JOIN pg_catalog.pg_type dt ON dt.oid = arg.typ\n          JOIN pg_catalog.pg_namespace dn ON dn.oid = dt.typnamespace\n          WHERE dt.typtype = 'd'\n            AND dt.typbasetype = jsonb_oid\n            AND (\n              dn.nspname = 'public'\n              OR dn.nspname = ANY(eql_v3_internal.owned_schemas())\n            )\n        )\n      )\n      -- Comment-marker fallback for hand-written inline-critical extension\n      -- functions that take no domain argument.\n      AND NOT EXISTS (\n        SELECT 1 FROM pg_catalog.pg_description d\n        WHERE d.objoid = p.oid\n          AND d.classoid = 'pg_catalog.pg_proc'::regclass\n          AND d.description LIKE 'eql-inline-critical%'\n      )\n  LOOP\n    EXECUTE pg_catalog.format(\n      'ALTER FUNCTION %s SET search_path = pg_catalog, extensions, public',\n      fn_oid::regprocedure\n    );\n  END LOOP;\nEND $$;\n"
+      }
+    ],
+    "postcheck": [
+      {
+        "description": "verify the \"eql_v3\" operator schema exists",
+        "sql": "SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = 'eql_v3')"
+      },
+      {
+        "description": "verify the concrete domain \"public.eql_v3_text_search\" exists",
+        "sql": "SELECT to_regtype('public.eql_v3_text_search') IS NOT NULL"
+      },
+      {
+        "description": "verify the eql_v3.eq operator function exists",
+        "sql": "SELECT EXISTS (SELECT 1 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'eql_v3' AND p.proname = 'eq')"
+      }
+    ]
+  }
+]
\ No newline at end of file
diff --git a/examples/prisma/migrations/cipherstash/refs/head.json b/examples/prisma/migrations/cipherstash/refs/head.json
index d3a5021e..dbf0ad84 100644
--- a/examples/prisma/migrations/cipherstash/refs/head.json
+++ b/examples/prisma/migrations/cipherstash/refs/head.json
@@ -1 +1 @@
-{"hash":"sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7","invariants":["cipherstash:install-eql-bundle-v1"]}
+{"hash":"sha256:1e86a0160ba305fa74516b6d9449218308b258a51a913c1fc907e629f44568a7","invariants":["cipherstash:install-eql-bundle-v1","cipherstash:install-eql-v3-bundle-v1"]}
diff --git a/examples/prisma/prisma/schema.prisma b/examples/prisma/prisma/schema.prisma
index f6c3746b..d009531e 100644
--- a/examples/prisma/prisma/schema.prisma
+++ b/examples/prisma/prisma/schema.prisma
@@ -1,44 +1,47 @@
-// @cipherstash/prisma-next example schema.
+// @cipherstash/prisma-next example schema — EQL v3.
 //
-// One User model exercising every cipherstash codec the extension
-// ships — string, double, bigint, date, boolean, and json. The
-// no-args constructors default every per-codec search-mode flag to
-// `true`, opting each column into the maximal index surface its
-// codec supports.
+// One User model exercising one v3 domain per plaintext family. Each
+// v3 constructor is argument-less and maps 1:1 to a concrete
+// `public.eql_v3_*` Postgres domain; the constructor IS the capability
+// set (there are no per-column search-mode flags in v3).
 //
-// Operator visibility per column follows from the codec's search-mode
-// flag set (see the package README's operator surface table):
+// Operator visibility per column follows from the domain's query
+// capabilities (see the package README's operator surface table):
 //
-//   - email         (string)  — cipherstashEq / Ilike / NotIlike /
-//                                Gt / Gte / Lt / Lte / Between /
-//                                NotBetween / InArray / NotInArray.
-//   - salary        (double)  — equality + order-and-range.
-//   - accountId     (bigint)  — equality + order-and-range.
-//   - birthday      (date)    — equality + order-and-range.
-//   - emailVerified (boolean) — equality only.
-//   - preferences   (json)    — cipherstashJsonbPathQueryFirst /
-//                                cipherstashJsonbGet SELECT-expr
-//                                helpers; cipherstashJsonbPathExists
-//                                predicate is currently no-op against
-//                                the live EQL bundle — see the
-//                                "Known limitations" section of the
-//                                package README.
+//   - email         (EncryptedTextSearch → eql_v3_text_search)
+//                     equality + order/range + free-text search:
+//                     cipherstashEq / Ne / InArray / NotInArray /
+//                     Gt / Gte / Lt / Lte / Between / NotBetween /
+//                     Ilike / NotIlike, cipherstashV3Asc / Desc.
+//   - salary        (EncryptedDoubleOrd → eql_v3_double_ord)
+//                     equality + order/range.
+//   - accountId     (EncryptedBigIntOrd → eql_v3_bigint_ord)
+//                     equality + order/range.
+//   - birthday      (EncryptedDateOrd → eql_v3_date_ord)
+//                     equality + order/range.
+//   - emailVerified (EncryptedBoolean → eql_v3_boolean)
+//                     STORAGE-ONLY: no search operators at all — every
+//                     cipherstash* predicate throws
+//                     EncryptionOperatorError on this column.
+//   - preferences   (EncryptedJson → eql_v3_json)
+//                     searchable JSON: cipherstashJsonContains
+//                     (encrypted jsonb `@>` containment).
+//
+// v3 emits NO search configs: the domain carries its own index
+// metadata, so there are no `eql_v2.add_search_config` /
+// `add_encrypted_constraint` migration ops (and none of that bundle's
+// quoted-identifier quirks). The `@@map("users")` / lowercase column
+// maps below are kept anyway: `user` is a reserved word in Postgres,
+// and stable physical names keep the example's SQL and docs boring.
 
 model User {
   id            String @id
-  email         cipherstash.EncryptedString()
-  salary        cipherstash.EncryptedDouble()
-  accountId     cipherstash.EncryptedBigInt()     @map("accountid")
-  birthday      cipherstash.EncryptedDate()
+  email         cipherstash.EncryptedTextSearch()
+  salary        cipherstash.EncryptedDoubleOrd()
+  accountId     cipherstash.EncryptedBigIntOrd()  @map("accountid")
+  birthday      cipherstash.EncryptedDateOrd()
   emailVerified cipherstash.EncryptedBoolean()    @map("emailverified")
   preferences   cipherstash.EncryptedJson()
 
-  // The CipherStash EQL bundle hits a SQL-injection-style bug in
-  // `eql_v2.add_encrypted_constraint` when the table or column name
-  // needs quoting (reserved words, mixed case, etc.). `user` is
-  // reserved in Postgres, so we map the table to `users`; the
-  // mixed-case columns are mapped to lowercase column names so the
-  // bundle's `%I` interpolation renders them unquoted. Drop these
-  // overrides once the upstream bundle bug is fixed.
   @@map("users")
 }
diff --git a/examples/prisma/src/db.ts b/examples/prisma/src/db.ts
index befbc1c1..2f4668b9 100644
--- a/examples/prisma/src/db.ts
+++ b/examples/prisma/src/db.ts
@@ -1,24 +1,29 @@
 /**
- * Wire the Prisma Next Postgres runtime with the cipherstash extension
- * in one call.
+ * Wire the Prisma Next Postgres runtime with the cipherstash EQL v3
+ * extension in one call.
  *
- * `cipherstashFromStack({ contractJson })` derives the encryption
- * schemas from the contract, constructs the `@cipherstash/stack`
- * `EncryptionClient` against your `CS_*` env vars or local profile,
- * builds the SDK adapter, and returns ready-to-spread arrays for
- * `extensions` and `middleware`. Override `schemas` only if you have
- * additional tables the contract does not model.
+ * `cipherstashFromStackV3({ contractJson })` derives the v3 encryption
+ * schemas from the contract (one `public.eql_v3_*` domain per column),
+ * constructs the `@cipherstash/stack` `EncryptionV3` client against
+ * your `CS_*` env vars or local profile, builds the SDK adapter, and
+ * returns ready-to-spread arrays for `extensions` and `middleware`.
+ * Override `schemasV3` only if you have additional tables the contract
+ * does not model.
+ *
+ * A v3 client is v3-only: a contract carrying v2 cipherstash codec ids
+ * is rejected at setup (use `cipherstashFromStack` from
+ * `@cipherstash/prisma-next/stack` for a v2 contract).
  */
 
 import 'dotenv/config'
 
-import { cipherstashFromStack } from '@cipherstash/prisma-next/stack'
+import { cipherstashFromStackV3 } from '@cipherstash/prisma-next/v3'
 import postgres from '@prisma-next/postgres/runtime'
 
 import type { Contract } from './prisma/contract.d'
 import contractJson from './prisma/contract.json' with { type: 'json' }
 
-const cipherstash = await cipherstashFromStack({ contractJson })
+const cipherstash = await cipherstashFromStackV3({ contractJson })
 
 export const db = postgres<Contract>({
   contractJson,
diff --git a/examples/prisma/src/index.ts b/examples/prisma/src/index.ts
index 02320c81..0a55bf31 100644
--- a/examples/prisma/src/index.ts
+++ b/examples/prisma/src/index.ts
@@ -1,40 +1,51 @@
 /**
- * @cipherstash/prisma-next example — end-to-end demo.
+ * @cipherstash/prisma-next example — end-to-end demo (EQL v3).
  *
- * Exercises every cipherstash codec the extension ships, plus the
- * trait-dispatched predicate operators and the sort helpers, against
- * a real Postgres + EQL database.
+ * Exercises one v3 domain per plaintext family, plus the
+ * trait-dispatched predicate operators and the encrypted ORDER BY
+ * helpers, against a real Postgres + EQL v3 database.
  *
- * The bulk-encrypt middleware groups every plaintext placeholder
- * (row payloads + search terms) into a single `bulkEncrypt` SDK
- * round-trip per `(table, column)` group before each query executes;
- * `decryptAll(rows)` mirrors the same coalescing on the read side
- * with one `bulkDecrypt` call per `(table, column)` group across
- * every envelope on every column of the result set.
+ * The bulk-encrypt middleware groups every plaintext placeholder into
+ * the minimum number of SDK crossings per query: row payloads go
+ * through one storage `bulkEncrypt` per `(table, column)` group, and
+ * operator operands are minted as ciphertext-free QUERY TERMS via
+ * `encryptQuery` (batched per flavour). `decryptAll(rows)` mirrors the
+ * read side with one `bulkDecrypt` call per `(table, column)` group
+ * across the result set.
+ *
+ * Column surface (the constructor IS the capability set in v3):
+ *
+ *   - email         eql_v3_text_search — eq/range/free-text + ORDER BY
+ *   - salary        eql_v3_double_ord  — eq + range + ORDER BY
+ *   - accountId     eql_v3_bigint_ord  — eq + range + ORDER BY
+ *   - birthday      eql_v3_date_ord    — eq + range + ORDER BY
+ *   - emailVerified eql_v3_boolean     — STORAGE-ONLY (no operators)
+ *   - preferences   eql_v3_json        — cipherstashJsonContains (@>)
  *
  * Prerequisites:
  *
- *   1. A Postgres database with the EQL bundle installed. The
+ *   1. A Postgres database with the EQL v3 bundle installed. The
  *      extension contributes its own contract space at
- *      `migrations/cipherstash/` which installs the EQL composite
- *      types, configuration table, and bundle SQL alongside the
- *      application schema — `pnpm migration:apply` runs it for you.
- *   2. A CipherStash workspace + ZeroKMS credentials. Populate
- *      `CS_WORKSPACE_CRN`, `CS_CLIENT_ID`, `CS_CLIENT_KEY`, and
- *      `CS_CLIENT_ACCESS_KEY` in `.env` (see `.env.example`).
+ *      `migrations/cipherstash/` which installs the EQL bundles
+ *      (v2 + v3 baselines) alongside the application schema —
+ *      `pnpm migration:apply` runs it for you.
+ *   2. A CipherStash workspace + ZeroKMS credentials. Run
+ *      `stash auth login` once, or populate `CS_WORKSPACE_CRN`,
+ *      `CS_CLIENT_ID`, `CS_CLIENT_KEY`, and `CS_CLIENT_ACCESS_KEY`
+ *      in `.env` (see `.env.example`).
  *   3. `DATABASE_URL` in `.env` pointing at the database from (1).
  */
 
 import 'dotenv/config'
 
 import {
-  cipherstashAsc,
+  cipherstashV3Asc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 
@@ -110,7 +121,8 @@ async function main() {
     await rangeQueryOnSalary()
     await betweenQueryOnBirthday()
     await inArrayQueryOnAccountId()
-    await equalityQueryOnEmailVerified()
+    await decryptStorageOnlyBoolean()
+    await jsonContainmentOnPreferences()
     await sortByEmailAsc()
   } finally {
     await runtime.close()
@@ -127,13 +139,13 @@ async function clearUsers(): Promise<void> {
 }
 
 async function insertUsers(): Promise<void> {
-  console.log('--- Insert (mixed-codec round-trip) ---')
+  console.log('--- Insert (mixed-domain round-trip) ---')
   await Promise.all(
     SEED_USERS.map((seed) =>
       db.orm.public.User.create({
         id: seed.id,
         email: EncryptedString.from(seed.email),
-        salary: EncryptedDouble.from(seed.salary),
+        salary: EncryptedNumber.from(seed.salary),
         accountId: EncryptedBigInt.from(seed.accountId),
         birthday: EncryptedDate.from(seed.birthday),
         emailVerified: EncryptedBoolean.from(seed.emailVerified),
@@ -142,12 +154,12 @@ async function insertUsers(): Promise<void> {
     ),
   )
   console.log(
-    `Inserted ${SEED_USERS.length} rows across six cipherstash codecs.`,
+    `Inserted ${SEED_USERS.length} rows across six cipherstash v3 domains.`,
   )
 }
 
 async function searchByEq(): Promise<void> {
-  console.log('\n--- cipherstashEq (string equality) ---')
+  console.log('\n--- cipherstashEq (text_search equality) ---')
   const rows = await db.orm.public.User.where((u) =>
     u.email.cipherstashEq('alice@example.com'),
   ).all()
@@ -159,11 +171,14 @@ async function searchByEq(): Promise<void> {
 }
 
 async function searchByIlikeAndDecrypt(): Promise<void> {
-  console.log('\n--- cipherstashIlike (string free-text-search) ---')
+  console.log('\n--- cipherstashIlike (text_search free-text tokens) ---')
+  // v3 free-text search is bloom-filter TOKEN matching (eql_v3.contains),
+  // not SQL ILIKE: the needle's tokens must appear in the ciphertext's
+  // index. 'example.com' matches the three @example.com addresses.
   const rows = await db.orm.public.User.where((u) =>
-    u.email.cipherstashIlike('%@example.com'),
+    u.email.cipherstashIlike('example.com'),
   ).all()
-  console.log(`Found ${rows.length} row(s) matching %@example.com.`)
+  console.log(`Found ${rows.length} row(s) whose email contains example.com.`)
   await decryptAll(rows)
   for (const row of rows) {
     console.log(`  ${row.id}: ${await row.email.decrypt()}`)
@@ -171,7 +186,7 @@ async function searchByIlikeAndDecrypt(): Promise<void> {
 }
 
 async function rangeQueryOnSalary(): Promise<void> {
-  console.log('\n--- cipherstashGt (double order-and-range) ---')
+  console.log('\n--- cipherstashGt (double_ord order-and-range) ---')
   const rows = await db.orm.public.User.where((u) =>
     u.salary.cipherstashGt(100_000),
   ).all()
@@ -183,7 +198,7 @@ async function rangeQueryOnSalary(): Promise<void> {
 }
 
 async function betweenQueryOnBirthday(): Promise<void> {
-  console.log('\n--- cipherstashBetween (date order-and-range) ---')
+  console.log('\n--- cipherstashBetween (date_ord order-and-range) ---')
   const lower = new Date('1985-01-01')
   const upper = new Date('1995-12-31')
   const rows = await db.orm.public.User.where((u) =>
@@ -193,7 +208,7 @@ async function betweenQueryOnBirthday(): Promise<void> {
 }
 
 async function inArrayQueryOnAccountId(): Promise<void> {
-  console.log('\n--- cipherstashInArray (bigint equality) ---')
+  console.log('\n--- cipherstashInArray (bigint_ord equality) ---')
   const rows = await db.orm.public.User.where((u) =>
     u.accountId.cipherstashInArray([100_000_000_001n, 100_000_000_004n]),
   ).all()
@@ -202,20 +217,41 @@ async function inArrayQueryOnAccountId(): Promise<void> {
   )
 }
 
-async function equalityQueryOnEmailVerified(): Promise<void> {
-  console.log('\n--- cipherstashInArray (boolean equality-only) ---')
-  // Booleans surface only the equality-trait operators; a single-element
-  // array is the canonical equality form on non-string codecs.
+async function decryptStorageOnlyBoolean(): Promise<void> {
+  console.log('\n--- eql_v3_boolean (storage-only round-trip) ---')
+  // The v3 boolean domain carries no search indexes: it round-trips
+  // true/false losslessly but surfaces NO cipherstash operators —
+  // calling one would throw EncryptionOperatorError. Filter on a
+  // searchable column and decrypt the boolean from the result set.
+  const rows = await db.orm.public.User.where((u) =>
+    u.email.cipherstashEq('carol@example.com'),
+  ).all()
+  await decryptAll(rows)
+  for (const row of rows) {
+    console.log(
+      `  ${row.id}: emailVerified=${await row.emailVerified.decrypt()}`,
+    )
+  }
+}
+
+async function jsonContainmentOnPreferences(): Promise<void> {
+  console.log('\n--- cipherstashJsonContains (encrypted jsonb @>) ---')
   const rows = await db.orm.public.User.where((u) =>
-    u.emailVerified.cipherstashInArray([true]),
+    u.preferences.cipherstashJsonContains({ theme: 'dark' }),
   ).all()
-  console.log(`Found ${rows.length} user(s) with emailVerified = true.`)
+  console.log(`Found ${rows.length} user(s) with a dark-theme preference.`)
+  await decryptAll(rows)
+  for (const row of rows) {
+    console.log(
+      `  ${row.id}: ${JSON.stringify(await row.preferences.decrypt())}`,
+    )
+  }
 }
 
 async function sortByEmailAsc(): Promise<void> {
-  console.log('\n--- cipherstashAsc (bare-column ORDER BY) ---')
+  console.log('\n--- cipherstashV3Asc (encrypted order-term ORDER BY) ---')
   const rows = await db.orm.public.User.orderBy((u) =>
-    cipherstashAsc(u.email),
+    cipherstashV3Asc(u.email),
   ).all()
   await decryptAll(rows)
   for (const row of rows) {
diff --git a/examples/prisma/src/prisma/contract.d.ts b/examples/prisma/src/prisma/contract.d.ts
index d6c3d2b9..995e0f8c 100644
--- a/examples/prisma/src/prisma/contract.d.ts
+++ b/examples/prisma/src/prisma/contract.d.ts
@@ -40,7 +40,7 @@ import type {
 } from '@prisma-next/contract/types';
 
 export type StorageHash =
-  StorageHashBase<'sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa'>;
+  StorageHashBase<'sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720'>;
 export type ExecutionHash = ExecutionHashBase<string>;
 export type ProfileHash =
   ProfileHashBase<'sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb'>;
@@ -57,12 +57,12 @@ export type FieldOutputTypes = {
   readonly public: {
     readonly User: {
       readonly id: CodecTypes['pg/text@1']['output'];
-      readonly email: CodecTypes['cipherstash/string@1']['output'];
-      readonly salary: CodecTypes['cipherstash/double@1']['output'];
-      readonly accountId: CodecTypes['cipherstash/bigint@1']['output'];
-      readonly birthday: CodecTypes['cipherstash/date@1']['output'];
-      readonly emailVerified: CodecTypes['cipherstash/boolean@1']['output'];
-      readonly preferences: CodecTypes['cipherstash/json@1']['output'];
+      readonly email: CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['output'];
+      readonly salary: CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['output'];
+      readonly accountId: CodecTypes['cipherstash/eql-v3/eql_v3_bigint_ord@1']['output'];
+      readonly birthday: CodecTypes['cipherstash/eql-v3/eql_v3_date_ord@1']['output'];
+      readonly emailVerified: CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['output'];
+      readonly preferences: CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['output'];
     };
   };
 };
@@ -70,12 +70,12 @@ export type FieldInputTypes = {
   readonly public: {
     readonly User: {
       readonly id: CodecTypes['pg/text@1']['input'];
-      readonly email: CodecTypes['cipherstash/string@1']['input'];
-      readonly salary: CodecTypes['cipherstash/double@1']['input'];
-      readonly accountId: CodecTypes['cipherstash/bigint@1']['input'];
-      readonly birthday: CodecTypes['cipherstash/date@1']['input'];
-      readonly emailVerified: CodecTypes['cipherstash/boolean@1']['input'];
-      readonly preferences: CodecTypes['cipherstash/json@1']['input'];
+      readonly email: CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['input'];
+      readonly salary: CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['input'];
+      readonly accountId: CodecTypes['cipherstash/eql-v3/eql_v3_bigint_ord@1']['input'];
+      readonly birthday: CodecTypes['cipherstash/eql-v3/eql_v3_date_ord@1']['input'];
+      readonly emailVerified: CodecTypes['cipherstash/eql-v3/eql_v3_boolean@1']['input'];
+      readonly preferences: CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['input'];
     };
   };
 };
@@ -102,44 +102,83 @@ type ContractBase = Omit<
                   readonly nullable: false;
                 };
                 readonly email: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/string@1';
+                  readonly nativeType: 'public.eql_v3_text_search';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_text_search@1';
                   readonly nullable: false;
                   readonly typeParams: {
-                    readonly equality: true;
-                    readonly freeTextSearch: true;
-                    readonly orderAndRange: true;
+                    readonly castAs: 'string';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: true;
+                    };
                   };
                 };
                 readonly salary: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/double@1';
+                  readonly nativeType: 'public.eql_v3_double_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'number';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly accountid: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/bigint@1';
+                  readonly nativeType: 'public.eql_v3_bigint_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'bigint';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly birthday: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/date@1';
+                  readonly nativeType: 'public.eql_v3_date_ord';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly typeParams: {
+                    readonly castAs: 'date';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly emailverified: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/boolean@1';
+                  readonly nativeType: 'public.eql_v3_boolean';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_boolean@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly equality: true };
+                  readonly typeParams: {
+                    readonly castAs: 'boolean';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
                 readonly preferences: {
-                  readonly nativeType: 'eql_v2_encrypted';
-                  readonly codecId: 'cipherstash/json@1';
+                  readonly nativeType: 'public.eql_v3_json';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_json@1';
                   readonly nullable: false;
-                  readonly typeParams: { readonly searchableJson: true };
+                  readonly typeParams: {
+                    readonly castAs: 'json';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                      readonly searchableJson: true;
+                    };
+                  };
                 };
               };
               primaryKey: { readonly columns: readonly ['id'] };
@@ -174,11 +213,14 @@ type ContractBase = Omit<
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/string@1';
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_text_search@1';
                   readonly typeParams: {
-                    readonly equality: true;
-                    readonly freeTextSearch: true;
-                    readonly orderAndRange: true;
+                    readonly castAs: 'string';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: true;
+                    };
                   };
                 };
               };
@@ -186,40 +228,76 @@ type ContractBase = Omit<
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/double@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'number';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly accountId: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/bigint@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'bigint';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly birthday: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/date@1';
-                  readonly typeParams: { readonly equality: true; readonly orderAndRange: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
+                  readonly typeParams: {
+                    readonly castAs: 'date';
+                    readonly capabilities: {
+                      readonly equality: true;
+                      readonly orderAndRange: true;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly emailVerified: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/boolean@1';
-                  readonly typeParams: { readonly equality: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_boolean@1';
+                  readonly typeParams: {
+                    readonly castAs: 'boolean';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                    };
+                  };
                 };
               };
               readonly preferences: {
                 readonly nullable: false;
                 readonly type: {
                   readonly kind: 'scalar';
-                  readonly codecId: 'cipherstash/json@1';
-                  readonly typeParams: { readonly searchableJson: true };
+                  readonly codecId: 'cipherstash/eql-v3/eql_v3_json@1';
+                  readonly typeParams: {
+                    readonly castAs: 'json';
+                    readonly capabilities: {
+                      readonly equality: false;
+                      readonly orderAndRange: false;
+                      readonly freeTextSearch: false;
+                      readonly searchableJson: true;
+                    };
+                  };
                 };
               };
             };
diff --git a/examples/prisma/src/prisma/contract.json b/examples/prisma/src/prisma/contract.json
index 9a06c3eb..d49354db 100644
--- a/examples/prisma/src/prisma/contract.json
+++ b/examples/prisma/src/prisma/contract.json
@@ -18,44 +18,54 @@
               "accountId": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/bigint@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "bigint"
                   }
                 }
               },
               "birthday": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/date@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_date_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "date"
                   }
                 }
               },
               "email": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/string@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_text_search@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "freeTextSearch": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "freeTextSearch": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "string"
                   }
                 }
               },
               "emailVerified": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/boolean@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_boolean@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true
+                    "capabilities": {},
+                    "castAs": "boolean"
                   }
                 }
               },
@@ -69,21 +79,27 @@
               "preferences": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/json@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_json@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "searchableJson": true
+                    "capabilities": {
+                      "searchableJson": true
+                    },
+                    "castAs": "json"
                   }
                 }
               },
               "salary": {
                 "nullable": false,
                 "type": {
-                  "codecId": "cipherstash/double@1",
+                  "codecId": "cipherstash/eql-v3/eql_v3_double_ord@1",
                   "kind": "scalar",
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "number"
                   }
                 }
               }
@@ -129,39 +145,49 @@
             "users": {
               "columns": {
                 "accountid": {
-                  "codecId": "cipherstash/bigint@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord@1",
+                  "nativeType": "public.eql_v3_bigint_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "bigint"
                   }
                 },
                 "birthday": {
-                  "codecId": "cipherstash/date@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_date_ord@1",
+                  "nativeType": "public.eql_v3_date_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "date"
                   }
                 },
                 "email": {
-                  "codecId": "cipherstash/string@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_text_search@1",
+                  "nativeType": "public.eql_v3_text_search",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "freeTextSearch": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "freeTextSearch": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "string"
                   }
                 },
                 "emailverified": {
-                  "codecId": "cipherstash/boolean@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_boolean@1",
+                  "nativeType": "public.eql_v3_boolean",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true
+                    "capabilities": {},
+                    "castAs": "boolean"
                   }
                 },
                 "id": {
@@ -170,20 +196,26 @@
                   "nullable": false
                 },
                 "preferences": {
-                  "codecId": "cipherstash/json@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_json@1",
+                  "nativeType": "public.eql_v3_json",
                   "nullable": false,
                   "typeParams": {
-                    "searchableJson": true
+                    "capabilities": {
+                      "searchableJson": true
+                    },
+                    "castAs": "json"
                   }
                 },
                 "salary": {
-                  "codecId": "cipherstash/double@1",
-                  "nativeType": "eql_v2_encrypted",
+                  "codecId": "cipherstash/eql-v3/eql_v3_double_ord@1",
+                  "nativeType": "public.eql_v3_double_ord",
                   "nullable": false,
                   "typeParams": {
-                    "equality": true,
-                    "orderAndRange": true
+                    "capabilities": {
+                      "equality": true,
+                      "orderAndRange": true
+                    },
+                    "castAs": "number"
                   }
                 }
               },
@@ -202,7 +234,7 @@
         "kind": "postgres-schema"
       }
     },
-    "storageHash": "sha256:b8c4febc9397cf1b68293cdb3b2afe9f568db6967f428e3f207e32575a2bc2fa"
+    "storageHash": "sha256:deb36a1ab7e51717f5ca822a32ff09a18cf3a0aaf1189262852c8953adba1720"
   },
   "capabilities": {
     "postgres": {
diff --git a/examples/prisma/test/e2e/README.md b/examples/prisma/test/e2e/README.md
index 96f575a2..9520ca98 100644
--- a/examples/prisma/test/e2e/README.md
+++ b/examples/prisma/test/e2e/README.md
@@ -1,27 +1,28 @@
-# Live PG + EQL + ZeroKMS e2e harness
+# Live PG + EQL v3 + ZeroKMS e2e harness
 
-This directory hosts the live-Postgres + EQL bundle + ZeroKMS end-to-end harness for the @cipherstash/prisma-next example app. Seven `*.e2e.test.ts` files cover one codec or scenario each:
+This directory hosts the live-Postgres + EQL v3 bundle + ZeroKMS end-to-end harness for the @cipherstash/prisma-next example app. Seven `*.e2e.test.ts` files cover one domain or scenario each:
 
-- `num.e2e.test.ts` — `EncryptedDouble` round-trip; `Gt`/`Gte`/`Lt`/`Lte`/`Between`/`Asc`/`Desc`.
-- `bigint.e2e.test.ts` — `EncryptedBigInt` round-trip; equality + range + sort.
-- `date.e2e.test.ts` — `EncryptedDate` round-trip; date range + sort.
-- `bool.e2e.test.ts` — `EncryptedBoolean` round-trip; `Eq` / `Ne` / `InArray`.
-- `json.e2e.test.ts` — `EncryptedJson` round-trip + `cipherstashJsonbPathQueryFirst` / `cipherstashJsonbGet` SELECT-expression helpers. The `cipherstashJsonbPathExists` predicate clause is skipped per the known limitation tracked at [TML-2504](https://linear.app/prisma-company/issue/TML-2504).
-- `str-range.e2e.test.ts` — `EncryptedString({ orderAndRange: true })` supports `Gt` + `Asc` + `Ilike` coexistence.
-- `mixed.e2e.test.ts` — mixed-codec query issues the minimum SDK round-trips (one per `(table, column)`).
+- `num.e2e.test.ts` — `eql_v3_double_ord` round-trip (decrypts to `EncryptedNumber`); `Gt`/`Gte`/`Lt`/`Lte`/`Between`; `cipherstashV3Asc`/`Desc` order-term sort.
+- `bigint.e2e.test.ts` — `eql_v3_bigint_ord` round-trip **lossless beyond `Number.MAX_SAFE_INTEGER`** (native `bigint` pipeline); equality + range + in-array + sort.
+- `date.e2e.test.ts` — `eql_v3_date_ord` round-trip; date range + order-term sort.
+- `bool.e2e.test.ts` — `eql_v3_boolean` is STORAGE-ONLY: round-trip works, the ORM binds no operator methods to the column, and the operator impls throw `EncryptionOperatorError` against it.
+- `json.e2e.test.ts` — `eql_v3_json` round-trip + `cipherstashJsonContains` (encrypted jsonb `@>`): top-level, multi-key, array-element, and nested containment, negative cases, and the loud rejection of the match-everything `{}` needle.
+- `str-range.e2e.test.ts` — `eql_v3_text_search` carries equality + order/range + free-text on one column: `Eq`, `Gt`, `V3Asc`/`V3Desc`, and `Ilike` (bloom-filter token containment — not SQL `ILIKE`) coexist.
+- `mixed.e2e.test.ts` — mixed-domain query issues the minimum framework-SDK crossings (one `bulkEncrypt` seam call per `(table, column)`; operands become ciphertext-free `encryptQuery` terms inside the v3 adapter).
 
 ## Local setup
 
 ```bash
+docker compose -f test/e2e/docker-compose.yml up -d   # from examples/prisma
 pnpm --filter @cipherstash/prisma-next-example test:e2e
 ```
 
 The harness's Vitest global setup (`global-setup.ts`):
 
-1. `docker compose up -d` and waits for `pg_isready`.
+1. Verifies the container is up (`pg_isready`) — you own the container lifecycle.
 2. Sets `DATABASE_URL` to the harness's local Postgres URL.
-3. Runs `prisma-next migrate` against the example app (installs the cipherstash baseline migration + the `users` table).
-4. Skips cleanly (logging the missing env var) when `CS_WORKSPACE_CRN` / `CS_CLIENT_ID` / `CS_CLIENT_KEY` / `CS_DEFAULT_KEY_ID` are unset, so PRs without secrets configured don't fail the suite.
+3. Runs `prisma-next migrate` against the example app (installs the cipherstash EQL v2 + v3 bundle baselines + the `users` table typed against `public.eql_v3_*` domains; v3 needs no per-column search configs).
+4. Requires CipherStash credentials: either `CS_*` variables in `.env` or a local profile from `stash auth login` (device-code flow).
 
 `vitest.config.ts` wires the global setup, scopes the run to `*.e2e.test.ts`, and pins `pool: 'threads'` + `maxWorkers: 1` + `isolate: false` + `fileParallelism: false` so every test file shares one Postgres connection and one CipherStash SDK encryption client (and the SDK isn't asked to run encrypts across files concurrently). Each test file truncates `users` in its `beforeAll` for clean-slate isolation.
 
@@ -29,13 +30,11 @@ The harness's Vitest global setup (`global-setup.ts`):
 
 The `docker-compose.yml` runs `postgres:16-alpine` on host port `54329` (non-standard to dodge a developer's locally installed Postgres on `5432`). `tmpfs` data volume so every boot starts from an empty cluster. Container name `cipherstash-e2e-postgres` avoids colliding with the workspace-root `docker-compose.yaml` (port `5433`, used by the framework's own e2e suite).
 
-## Known limitations covered by skips
+## v2 limitations that no longer apply
 
-- **`cipherstashJsonbPathExists` predicate clause.** The EQL bundle's `jsonb_path_exists` function expects a hashed STE-VEC selector computed client-side by the CipherStash SDK's `selector(...)` API; the framework currently binds the JSONpath as a plain `pg/text@1` `ParamRef`. Predicate queries return zero rows. Tracked at [TML-2504](https://linear.app/prisma-company/issue/TML-2504); the round-trip and the two SELECT-expression helpers work correctly against the same column.
-- **`EncryptedBigInt` capped at `Number.MAX_SAFE_INTEGER`.** `@cipherstash/stack`'s SDK and ZeroKMS only accept `JsPlaintext = string | number | boolean | object | array` for plaintexts (no `bigint`); the example app's SDK adapter at `src/sdk.ts` converts `bigint → Number` with an eager `Number.MAX_SAFE_INTEGER` bounds check. Values beyond the safe-integer range cannot be encrypted today.
+The v2 iteration of this harness carried two known-limitation carve-outs; both are gone on v3:
 
-## EQL bundle quoted-identifier workaround
+- **JSON predicates work.** v2's `cipherstashJsonbPathExists` needed client-side STE-VEC selector hashing and was skipped. v3's containment model (`cipherstashJsonContains` → `@>` with an `eql_v3.query_jsonb` term) runs end-to-end — no skips in `json.e2e.test.ts`.
+- **BigInt is lossless.** v2 converted `bigint → Number` at the SDK boundary and capped values at `Number.MAX_SAFE_INTEGER`. v3's protect-ffi wire is natively `bigint` (bounds-checked int8), and `bigint.e2e.test.ts` pins a 2^53 + 1 round-trip.
 
-`eql_v2.add_encrypted_constraint(table, column)` interpolates `%I` for both the constraint-name prefix **and** the (already double-quoted) identifier suffix, producing invalid SQL like `CONSTRAINT eql_v2_encrypted_constraint_"users"_"accountId"` whenever either name needs quoting (mixed case, reserved word, etc.).
-
-Worked around in the example schema by `@map`-ing `accountId` → `accountid` and `emailVerified` → `emailverified` (matching the existing `@@map("users")` workaround for the reserved-word case). File upstream + drop the workaround when the bundle is fixed.
+One new-in-v3 refusal is deliberately pinned rather than worked around: `eql_v3_boolean` is storage-only, so `bool.e2e.test.ts` asserts the operator surface is absent/throwing instead of querying it.
diff --git a/examples/prisma/test/e2e/bigint.e2e.test.ts b/examples/prisma/test/e2e/bigint.e2e.test.ts
index 8d363c10..a4d986ca 100644
--- a/examples/prisma/test/e2e/bigint.e2e.test.ts
+++ b/examples/prisma/test/e2e/bigint.e2e.test.ts
@@ -1,51 +1,45 @@
 /**
- * End-to-end round-trip for `EncryptedBigInt` against live
- * Postgres + EQL bundle + ZeroKMS.
+ * End-to-end round-trip for the `eql_v3_bigint_ord` domain against
+ * live Postgres + EQL v3 + ZeroKMS.
  *
- * Pins the cipherstash bigint codec's encrypt + decrypt + range +
- * sort behaviour with bigint-specific assertions on top of the
- * general numeric coverage in `num.e2e.test.ts`.
- *
- * # Known limitation: Number.MAX_SAFE_INTEGER cap
- *
- * The underlying `@cipherstash/stack` SDK accepts only the
- * `string | number | boolean | object | array` `JsPlaintext` shape for
- * `bulkEncrypt`, and ZeroKMS's `big_int` cast rejects string
- * plaintexts (`Cannot convert String to BigInt`). The example SDK
- * adapter therefore converts `bigint` → JS `number` and throws
- * eagerly above `Number.MAX_SAFE_INTEGER` rather than silently
- * truncating. Consequently the live BigInt round-trip is bounded by
- * `Number.MAX_SAFE_INTEGER` (2^53 − 1) today; lifting the cap
- * requires SDK work documented in `examples/prisma/
- * src/sdk.ts` (`toJsPlaintext`). The negative test below pins the
- * boundary explicitly.
+ * Pins the v3 bigint pipeline's encrypt + decrypt + equality + range +
+ * sort behaviour — INCLUDING losslessness beyond
+ * `Number.MAX_SAFE_INTEGER`. The v2 example was capped at 2^53 − 1
+ * (its SDK adapter converted `bigint → Number`); v3's protect-ffi
+ * eqlVersion-3 wire handles `bigint` natively as a bounds-checked
+ * int8, so 2^53 + 1 (unrepresentable as a JS number) must survive the
+ * full round-trip and participate in equality/range/sort correctly.
  */
 
 import {
-  cipherstashAsc,
+  cipherstashV3Asc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
 
+// 2^53 + 1: NOT representable as a JS number. Losslessness here proves
+// the pipeline is bigint end-to-end (protect-ffi's eqlVersion-3 int8).
+const UNSAFE_BIG = 9_007_199_254_740_993n
+
 const SEED = [
   { id: 'e2e-bigint-0', accountId: 1_000_000_000_001n },
   { id: 'e2e-bigint-1', accountId: 1_000_000_000_002n },
   { id: 'e2e-bigint-2', accountId: 9_000_000_000_000_000n },
-  { id: 'e2e-bigint-3', accountId: BigInt(Number.MAX_SAFE_INTEGER) },
+  { id: 'e2e-bigint-3', accountId: UNSAFE_BIG },
 ] as const
 
 function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(`${s.id}@example.com`),
-    salary: EncryptedDouble.from(50_000),
+    salary: EncryptedNumber.from(50_000),
     accountId: EncryptedBigInt.from(s.accountId),
     birthday: EncryptedDate.from(new Date('1990-01-01')),
     emailVerified: EncryptedBoolean.from(true),
@@ -53,14 +47,14 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedBigInt e2e (live PG + EQL + ZeroKMS)', () => {
+describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
     await Promise.all(SEED.map((s) => db.orm.public.User.create(seedRow(s))))
   })
 
-  it('round-trips an EncryptedBigInt through bulkEncrypt + bulkDecrypt', async () => {
+  it('round-trips losslessly, including beyond Number.MAX_SAFE_INTEGER', async () => {
     const rows = await db.orm.public.User.all()
     expect(rows).toHaveLength(SEED.length)
     await decryptAll(rows)
@@ -68,10 +62,19 @@ describe('EncryptedBigInt e2e (live PG + EQL + ZeroKMS)', () => {
     for (const s of SEED) {
       const r = byId.get(s.id)
       expect(r, `seed row ${s.id} present`).toBeDefined()
-      expect(r ? await r.accountId.decrypt() : undefined).toBe(s.accountId)
+      const got = r ? await r.accountId.decrypt() : undefined
+      expect(typeof got, `${s.id} must decrypt to a JS bigint`).toBe('bigint')
+      expect(got).toBe(s.accountId)
     }
   })
 
+  it('cipherstashEq selects exactly the row holding the unsafe-range value', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.accountId.cipherstashEq(UNSAFE_BIG),
+    ).all()
+    expect(rows.map((r) => r.id)).toEqual(['e2e-bigint-3'])
+  })
+
   it('cipherstashGt filters by encrypted bigint numeric order', async () => {
     const rows = await db.orm.public.User.where((u) =>
       u.accountId.cipherstashGt(1_000_000_000_002n),
@@ -107,10 +110,7 @@ describe('EncryptedBigInt e2e (live PG + EQL + ZeroKMS)', () => {
 
   it('cipherstashInArray returns rows whose value matches any of the supplied bigints', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashInArray([
-        1_000_000_000_001n,
-        BigInt(Number.MAX_SAFE_INTEGER),
-      ]),
+      u.accountId.cipherstashInArray([1_000_000_000_001n, UNSAFE_BIG]),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-bigint-0',
@@ -118,9 +118,12 @@ describe('EncryptedBigInt e2e (live PG + EQL + ZeroKMS)', () => {
     ])
   })
 
-  it('cipherstashAsc orders by bigint value (bare-column ORDER BY)', async () => {
+  it('cipherstashV3Asc orders by bigint value via the encrypted order term', async () => {
+    // 2^53 + 1 = 9_007_199_254_740_993 > 9_000_000_000_000_000, so the
+    // unsafe-range row sorts LAST — on the true int8 value, not a lossy
+    // float projection.
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashAsc(u.accountId),
+      cipherstashV3Asc(u.accountId),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-bigint-0',
@@ -129,16 +132,4 @@ describe('EncryptedBigInt e2e (live PG + EQL + ZeroKMS)', () => {
       'e2e-bigint-3',
     ])
   })
-
-  it('accepts bigint plaintexts above Number.MAX_SAFE_INTEGER at construction', () => {
-    expect(() =>
-      EncryptedBigInt.from(BigInt(Number.MAX_SAFE_INTEGER) + 1n),
-    ).not.toThrow()
-    // The construction is fine — the failure surfaces at the SDK
-    // boundary (`toJsPlaintext`) the moment a bulk-encrypt fires for
-    // this envelope. We pin the boundary in the SDK adapter's unit
-    // test rather than wire a live-ZeroKMS round-trip we expect to
-    // fail; surfacing the limit eagerly at the call site keeps test
-    // signals readable.
-  })
 })
diff --git a/examples/prisma/test/e2e/bool.e2e.test.ts b/examples/prisma/test/e2e/bool.e2e.test.ts
index 9c7a77e1..c91ad530 100644
--- a/examples/prisma/test/e2e/bool.e2e.test.ts
+++ b/examples/prisma/test/e2e/bool.e2e.test.ts
@@ -1,27 +1,33 @@
 /**
- * End-to-end round-trip for `EncryptedBoolean` against live
- * Postgres + EQL bundle + ZeroKMS.
+ * End-to-end round-trip for the `eql_v3_boolean` domain against live
+ * Postgres + EQL v3 + ZeroKMS.
+ *
+ * The v3 boolean domain is STORAGE-ONLY: it carries no search indexes
+ * and advertises no query capabilities, so this file pins:
  *
- * Booleans surface only the equality-trait operators (no
- * order-and-range) so this file pins:
  *   - INSERT + decrypt round-trip recovers `true` / `false`.
- *   - Equality filters to the matching set. Note: `cipherstashEq` is
- *     the legacy single-codec operator pinned to `cipherstash/string@1`.
- *     For non-string equality, the trait-namespaced
- *     `cipherstashInArray([value])` is the canonical form (see
- *     `src/index.ts`'s boolean demo). We exercise
- *     `cipherstashInArray` (the trait-dispatched live form) and
- *     `cipherstashNe` (the inequality direction).
+ *   - The ORM accessor binds NO cipherstash operator methods to the
+ *     column (runtime trait dispatch: the codec has no traits, so
+ *     `u.emailVerified.cipherstashEq` is `undefined`).
+ *   - Calling the operator impls directly against the column throws
+ *     `EncryptionOperatorError` (the per-domain capability gate).
+ *
+ * The refusal is a FEATURE, not a gap: a storage-only domain has no
+ * searchable term to mint, and silently returning zero rows would be
+ * worse than the loud error. Columns that need boolean equality
+ * should model the flag differently (e.g. a text_eq status column).
  */
 
 import {
+  cipherstashV3QueryOperations,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
+  EncryptionOperatorError,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -37,7 +43,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(`${s.id}@example.com`),
-    salary: EncryptedDouble.from(50_000),
+    salary: EncryptedNumber.from(50_000),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(new Date('1990-01-01')),
     emailVerified: EncryptedBoolean.from(s.emailVerified),
@@ -45,14 +51,14 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedBoolean e2e (live PG + EQL + ZeroKMS)', () => {
+describe('eql_v3_boolean storage-only e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
     await Promise.all(SEED.map((s) => db.orm.public.User.create(seedRow(s))))
   })
 
-  it('round-trips an EncryptedBoolean through bulkEncrypt + bulkDecrypt', async () => {
+  it('round-trips true and false through bulkEncrypt + bulkDecrypt', async () => {
     const rows = await db.orm.public.User.all()
     expect(rows).toHaveLength(SEED.length)
     await decryptAll(rows)
@@ -66,36 +72,71 @@ describe('EncryptedBoolean e2e (live PG + EQL + ZeroKMS)', () => {
     }
   })
 
-  it('cipherstashInArray([true]) returns the verified subset', async () => {
-    const rows = await db.orm.public.User.where((u) =>
-      u.emailVerified.cipherstashInArray([true]),
-    ).all()
-    expect(rows.map((r) => r.id).sort()).toEqual(['e2e-bool-0', 'e2e-bool-2'])
-  })
-
-  it('cipherstashInArray([false]) returns the unverified subset', async () => {
-    const rows = await db.orm.public.User.where((u) =>
-      u.emailVerified.cipherstashInArray([false]),
-    ).all()
-    expect(rows.map((r) => r.id).sort()).toEqual(['e2e-bool-1', 'e2e-bool-3'])
-  })
-
-  it('cipherstashInArray([true, false]) returns the entire population', async () => {
-    const rows = await db.orm.public.User.where((u) =>
-      u.emailVerified.cipherstashInArray([true, false]),
-    ).all()
-    expect(rows.map((r) => r.id).sort()).toEqual([
-      'e2e-bool-0',
-      'e2e-bool-1',
-      'e2e-bool-2',
-      'e2e-bool-3',
-    ])
+  it('binds no cipherstash operator methods on the storage-only column', async () => {
+    // Runtime trait dispatch: the eql_v3_boolean codec advertises no
+    // cipherstash traits, so the model accessor never attaches the
+    // operator methods. Every method the other suites use must be
+    // absent here. (Type-level visibility agrees: none of these
+    // compile on `u.emailVerified`, hence the untyped probe.)
+    const observed: Record<string, string> = {}
+    await db.orm.public.User.where((u) => {
+      const probe = u.emailVerified as unknown as Record<string, unknown>
+      for (const method of [
+        'cipherstashEq',
+        'cipherstashNe',
+        'cipherstashInArray',
+        'cipherstashNotInArray',
+        'cipherstashGt',
+        'cipherstashGte',
+        'cipherstashLt',
+        'cipherstashLte',
+        'cipherstashBetween',
+        'cipherstashNotBetween',
+        'cipherstashIlike',
+        'cipherstashNotIlike',
+        'cipherstashJsonContains',
+      ]) {
+        observed[method] = typeof probe[method]
+      }
+      return u.id.isNotNull()
+    }).all()
+    for (const [method, type] of Object.entries(observed)) {
+      expect(type, `${method} must not bind to eql_v3_boolean`).toBe(
+        'undefined',
+      )
+    }
   })
 
-  it('cipherstashNe([true]) excludes the equality match', async () => {
-    const rows = await db.orm.public.User.where((u) =>
-      u.emailVerified.cipherstashNe(true),
-    ).all()
-    expect(rows.map((r) => r.id).sort()).toEqual(['e2e-bool-1', 'e2e-bool-3'])
+  it('the operator impls throw EncryptionOperatorError against the boolean column', () => {
+    const ops = cipherstashV3QueryOperations()
+    // Reach the impls the way a custom builder could: with the column
+    // expression captured from the typed SQL surface. The per-domain
+    // capability gate must refuse the storage-only domain loudly.
+    const attempts: ReadonlyArray<readonly [string, readonly unknown[]]> = [
+      ['cipherstashEq', [true]],
+      ['cipherstashNe', [false]],
+      ['cipherstashInArray', [[true, false]]],
+      ['cipherstashNotInArray', [[true]]],
+      ['cipherstashGt', [false]],
+      ['cipherstashBetween', [false, true]],
+      ['cipherstashIlike', ['tru']],
+      ['cipherstashJsonContains', [{ verified: true }]],
+    ]
+    db.sql.public.users
+      .select((f) => {
+        for (const [method, args] of attempts) {
+          const op = ops[method]
+          expect(op, `operator ${method} registered`).toBeDefined()
+          expect(
+            // The select-scope field is the same column-bound expression
+            // the where-scope hands to operator impls; the impl parameter
+            // type is wider than the scope field type, hence the cast.
+            () => op?.impl(f.emailverified as never, ...(args as never[])),
+            `${method} must refuse eql_v3_boolean`,
+          ).toThrow(EncryptionOperatorError)
+        }
+        return { id: f.id }
+      })
+      .build()
   })
 })
diff --git a/examples/prisma/test/e2e/date.e2e.test.ts b/examples/prisma/test/e2e/date.e2e.test.ts
index b4aaf5b4..005d8c36 100644
--- a/examples/prisma/test/e2e/date.e2e.test.ts
+++ b/examples/prisma/test/e2e/date.e2e.test.ts
@@ -1,26 +1,27 @@
 /**
- * End-to-end round-trip for `EncryptedDate` against live
- * Postgres + EQL bundle + ZeroKMS.
+ * End-to-end round-trip for the `eql_v3_date_ord` domain against
+ * live Postgres + EQL v3 + ZeroKMS.
  *
  * Pins:
  *   - INSERT + decrypt round-trip recovers the source `Date`.
  *   - `cipherstashGt(<date>)` returns rows whose date is later.
- *   - `cipherstashAsc` orders by calendar date.
  *   - `cipherstashBetween` filters a closed interval.
+ *   - `cipherstashV3Asc` / `cipherstashV3Desc` order by calendar date
+ *     via the encrypted order term (`eql_v3.ord_term(col)`).
  *
- * Encoded form is ISO 8601 (`.toISOString()`); both ZeroKMS and the
- * EQL bundle accept the textual form for `cast_as: 'date'`.
+ * protect-ffi's eqlVersion-3 wire accepts `Date` plaintexts natively
+ * for `cast_as: 'date'` (calendar-day precision).
  */
 
 import {
-  cipherstashAsc,
-  cipherstashDesc,
+  cipherstashV3Asc,
+  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
@@ -37,7 +38,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(`${s.id}@example.com`),
-    salary: EncryptedDouble.from(50_000),
+    salary: EncryptedNumber.from(50_000),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(s.birthday),
     emailVerified: EncryptedBoolean.from(true),
@@ -45,7 +46,7 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedDate e2e (live PG + EQL + ZeroKMS)', () => {
+describe('EncryptedDate (eql_v3_date_ord) e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
@@ -61,9 +62,8 @@ describe('EncryptedDate e2e (live PG + EQL + ZeroKMS)', () => {
       const r = byId.get(s.id)
       expect(r, `seed row ${s.id} present`).toBeDefined()
       const got = r ? await r.birthday.decrypt() : undefined
-      // The cipherstash date codec round-trips through `cast_as: 'date'`
-      // which is calendar-day-precision; comparing day-equivalence is
-      // the meaningful assertion.
+      // `cast_as: 'date'` is calendar-day precision; comparing
+      // day-equivalence is the meaningful assertion.
       expect(got).toBeInstanceOf(Date)
       expect((got as Date).toISOString().slice(0, 10)).toBe(
         s.birthday.toISOString().slice(0, 10),
@@ -88,9 +88,9 @@ describe('EncryptedDate e2e (live PG + EQL + ZeroKMS)', () => {
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-date-1', 'e2e-date-2'])
   })
 
-  it('cipherstashAsc orders by calendar date (bare-column ORDER BY)', async () => {
+  it('cipherstashV3Asc orders by calendar date via the encrypted order term', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashAsc(u.birthday),
+      cipherstashV3Asc(u.birthday),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-date-0',
@@ -100,9 +100,9 @@ describe('EncryptedDate e2e (live PG + EQL + ZeroKMS)', () => {
     ])
   })
 
-  it('cipherstashDesc reverses the date order', async () => {
+  it('cipherstashV3Desc reverses the date order', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashDesc(u.birthday),
+      cipherstashV3Desc(u.birthday),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-date-3',
diff --git a/examples/prisma/test/e2e/global-setup.ts b/examples/prisma/test/e2e/global-setup.ts
index 82c7dafd..9bbd9937 100644
--- a/examples/prisma/test/e2e/global-setup.ts
+++ b/examples/prisma/test/e2e/global-setup.ts
@@ -12,10 +12,11 @@
  *      harness reports a clear actionable error when it's not up
  *      rather than orchestrating Docker itself).
  *   3. Apply the example app's migrations against the harness DB —
- *      the cipherstash baseline (EQL bundle install + per-column
- *      search configs) plus the application `users` table. The
- *      apply is idempotent at the marker level so a re-run on a
- *      warm container is a no-op.
+ *      the cipherstash baselines (EQL v2 + v3 bundle installs) plus
+ *      the application `users` table (typed against the
+ *      `public.eql_v3_*` domains; v3 needs no per-column search
+ *      configs). The apply is idempotent at the marker level so a
+ *      re-run on a warm container is a no-op.
  *   4. Truncate the `users` table for a clean slate per harness
  *      boot. Each test file owns its own seed data with file-scoped
  *      ID prefixes; the truncate guards against state bleeding
@@ -130,7 +131,8 @@ export default async function setup(): Promise<() => Promise<void>> {
   }
 
   // Clean slate for the suite. The `users` table is the only data-bearing
-  // application table; the EQL bundle tables (`eql_v2_configuration` etc.)
+  // application table; the EQL bundle state (`eql_v2_configuration`,
+  // the `public.eql_v3_*` domains, the `eql_v3` schema, etc.)
   // are state we want to keep.
   const truncate = spawnSync(
     'docker',
diff --git a/examples/prisma/test/e2e/json.e2e.test.ts b/examples/prisma/test/e2e/json.e2e.test.ts
index de62144d..d618b4a8 100644
--- a/examples/prisma/test/e2e/json.e2e.test.ts
+++ b/examples/prisma/test/e2e/json.e2e.test.ts
@@ -1,52 +1,34 @@
 /**
- * End-to-end round-trip for `EncryptedJson` against live
- * Postgres + EQL bundle + ZeroKMS.
+ * End-to-end round-trip for the `eql_v3_json` domain against live
+ * Postgres + EQL v3 + ZeroKMS.
+ *
+ * v3 searchable JSON is containment-only: the ste_vec index answers
+ * encrypted jsonb `@>` via `cipherstashJsonContains`, with the operand
+ * minted as a ciphertext-free `eql_v3.query_jsonb` term. The v2
+ * `cipherstashJsonbPathQueryFirst` / `cipherstashJsonbGet` /
+ * `cipherstashJsonbPathExists` helpers do not exist in v3 (and with
+ * them goes the v2 suite's "selector hashing" known-limitation skip —
+ * containment works end-to-end).
  *
  * Pins:
  *   - INSERT + decrypt round-trip recovers the source JSON object.
- *   - `cipherstashJsonbPathExists('$.<key>')` filters rows by
- *     STE-VEC selector membership.
- *
- * # Known limitation: STE-VEC selectors require client-side hashing
- *
- * The cipherstash JSON codec stores values with an STE-VEC index;
- * each JSON path is represented in the index as a *hashed* selector
- * computed by the CipherStash client at write time. The
- * `eql_v2.jsonb_path_exists` function expects that same hashed
- * selector at query time — passing a raw JSONpath string
- * (`'$.theme'`) probes the index for a path that has not been
- * hashed, so the lookup misses every row.
- *
- * The framework's current operator lowering binds the JSONpath as a
- * plain `pg/text@1` `ParamRef`. The wire result is a syntactically
- * valid call that the EQL function accepts and runs, but no rows
- * match because the encrypted index entries are keyed by hashed
- * selectors, not the raw path. Bridging this requires either:
- *
- *   - a client-side hashing step before the SQL fires (a new
- *     middleware that observes JSON-path arguments and rewrites them
- *     via the SDK's `selector(...)` API), or
- *   - an EQL-side overload that accepts plaintext paths and hashes
- *     them server-side.
- *
- * Both routes are tracked as a follow-up at
- * https://linear.app/prisma-company/issue/TML-2504. The test below
- * pins the round-trip + decrypt behaviour (which works today) and
- * the JSON SELECT-expression helpers' availability; the predicate
- * side is marked as a known limitation with a `.skip` and a pointer
- * to this comment, so the regression status is visible at a glance.
+ *   - `cipherstashJsonContains` selects by top-level, multi-key,
+ *     nested-array, and nested-object containment (exact jsonb `@>`
+ *     semantics, no false positives).
+ *   - Negative cases: non-matching needles select zero rows.
+ *   - The empty-object needle (`doc @> '{}'` — true for EVERY row) is
+ *     rejected loudly instead of silently selecting the whole table.
  */
 
 import {
-  cipherstashJsonbGet,
-  cipherstashJsonbPathQueryFirst,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
+  EncryptionOperatorError,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -54,15 +36,29 @@ import { db, ensureConnected, truncateUsers } from './harness'
 const SEED = [
   {
     id: 'e2e-json-0',
-    preferences: { theme: 'dark', notifications: true, locale: 'en-US' },
+    preferences: {
+      theme: 'dark',
+      notifications: true,
+      locale: 'en-US',
+      tags: ['alpha', 'beta'],
+    },
   },
   {
     id: 'e2e-json-1',
-    preferences: { theme: 'light', notifications: false, locale: 'de-DE' },
+    preferences: {
+      theme: 'light',
+      notifications: false,
+      locale: 'de-DE',
+      tags: ['beta'],
+    },
   },
   {
     id: 'e2e-json-2',
-    preferences: { theme: 'system', notifications: true },
+    preferences: {
+      theme: 'dark',
+      notifications: true,
+      nested: { level: 3, admin: true },
+    },
   },
 ] as const
 
@@ -70,7 +66,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(`${s.id}@example.com`),
-    salary: EncryptedDouble.from(50_000),
+    salary: EncryptedNumber.from(50_000),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(new Date('1990-01-01')),
     emailVerified: EncryptedBoolean.from(true),
@@ -78,7 +74,7 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedJson e2e (live PG + EQL + ZeroKMS)', () => {
+describe('EncryptedJson (eql_v3_json) e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
@@ -97,35 +93,62 @@ describe('EncryptedJson e2e (live PG + EQL + ZeroKMS)', () => {
     }
   })
 
-  it.skip('cipherstashJsonbPathExists filters by JSON path (KNOWN LIMITATION: needs client-side selector hashing)', async () => {
+  it('cipherstashJsonContains selects by top-level key/value containment', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonbPathExists('$.locale'),
+      u.preferences.cipherstashJsonContains({ theme: 'dark' }),
     ).all()
+    expect(rows.map((r) => r.id).sort()).toEqual(['e2e-json-0', 'e2e-json-2'])
+  })
+
+  it('cipherstashJsonContains requires ALL needle keys (multi-key containment)', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({
+        theme: 'dark',
+        locale: 'en-US',
+      }),
+    ).all()
+    expect(rows.map((r) => r.id)).toEqual(['e2e-json-0'])
+  })
+
+  it('cipherstashJsonContains matches array-element containment', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({ tags: ['beta'] }),
+    ).all()
+    // jsonb `@>`: ['alpha','beta'] ⊇ ['beta'] and ['beta'] ⊇ ['beta'].
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-json-0', 'e2e-json-1'])
   })
 
-  it('exposes cipherstashJsonbPathQueryFirst as a typed SELECT-expression helper', () => {
-    // Type-level: the helper accepts an `Expression<ScopeField>` and
-    // returns an `Expression` typed as `cipherstash/json@1`. Wiring
-    // it into a `db.sql.public.users.select(...)` projection exercises the
-    // typed surface; the live SQL execution is held back until the
-    // STE-VEC selector hashing gap closes (see file docblock).
-    const projection = db.sql.public.users
-      .select((f) => ({
-        id: f.id,
-        themeNode: cipherstashJsonbPathQueryFirst(f.preferences, '$.theme'),
-      }))
-      .build()
-    expect(projection).toBeDefined()
+  it('cipherstashJsonContains matches nested-object containment', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({ nested: { admin: true } }),
+    ).all()
+    expect(rows.map((r) => r.id)).toEqual(['e2e-json-2'])
+  })
+
+  it('cipherstashJsonContains returns zero rows for non-matching needles', async () => {
+    const wrongValue = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({ theme: 'sepia' }),
+    ).all()
+    expect(wrongValue).toHaveLength(0)
+
+    const wrongKey = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({ timezone: 'UTC' }),
+    ).all()
+    expect(wrongKey).toHaveLength(0)
+
+    const partialNested = await db.orm.public.User.where((u) =>
+      u.preferences.cipherstashJsonContains({
+        nested: { level: 3, admin: false },
+      }),
+    ).all()
+    expect(partialNested).toHaveLength(0)
   })
 
-  it('exposes cipherstashJsonbGet as a typed SELECT-expression helper', () => {
-    const projection = db.sql.public.users
-      .select((f) => ({
-        id: f.id,
-        themeNode: cipherstashJsonbGet(f.preferences, 'theme'),
-      }))
-      .build()
-    expect(projection).toBeDefined()
+  it('rejects the match-everything empty-object needle loudly', () => {
+    expect(() =>
+      db.orm.public.User.where((u) =>
+        u.preferences.cipherstashJsonContains({}),
+      ),
+    ).toThrow(EncryptionOperatorError)
   })
 })
diff --git a/examples/prisma/test/e2e/mixed.e2e.test.ts b/examples/prisma/test/e2e/mixed.e2e.test.ts
index aa386104..86252580 100644
--- a/examples/prisma/test/e2e/mixed.e2e.test.ts
+++ b/examples/prisma/test/e2e/mixed.e2e.test.ts
@@ -1,47 +1,49 @@
 /**
- * End-to-end mixed-codec query against live Postgres + EQL bundle
- * + ZeroKMS.
+ * End-to-end mixed-domain query against live Postgres + EQL v3 +
+ * ZeroKMS.
  *
- * Pins the cross-codec invariants:
- *   - A single query that touches multiple cipherstash columns of
- *     different types in WHERE + ORDER BY succeeds end-to-end.
- *   - Bulk-encrypt batches every search-term envelope into the
- *     minimum number of SDK round-trips — one `bulkEncrypt` per
- *     `(table, column)` group (also covered by the bulk-encrypt
- *     middleware unit tests in
- *     `packages/prisma-next/test/bulk-encrypt-middleware.test.ts`).
+ * Pins the cross-domain invariants:
+ *   - A single query that touches multiple cipherstash v3 columns of
+ *     different domains in WHERE + ORDER BY succeeds end-to-end.
+ *   - The bulk-encrypt middleware batches every operand into the
+ *     minimum number of framework-SDK crossings — one `bulkEncrypt`
+ *     seam call per `(table, column)` group. (Inside the v3 SDK
+ *     adapter, WHERE operands route through `encryptQuery` as
+ *     ciphertext-free query terms; the seam count is what the
+ *     middleware controls and what this suite observes.)
  *
- * Round-trip counts are observed by wrapping a fresh `CipherstashSdk`
- * (built from `cipherstashFromStack({ contractJson }).encryptionClient`)
- * with a counting decorator and threading the wrapped instance into a
- * private `db` runtime. Concretely:
+ * Crossing counts are observed by wrapping a fresh `CipherstashSdk`
+ * (built from `cipherstashFromStackV3({ contractJson }).encryptionClient`
+ * via `createCipherstashV3Sdk`) with a counting decorator and threading
+ * the wrapped instance into a private `db` runtime. Concretely:
  *
- *   - WHERE clause touches `email` (string) + `salary` (double) +
- *     `birthday` (date) + `emailVerified` (boolean) — four cipher
- *     columns, so **4 bulkEncrypt calls** for the search terms.
+ *   - WHERE touches `email` (text_search) + `salary` (double_ord) +
+ *     `birthday` (date_ord) — three cipher columns, so **3 bulkEncrypt
+ *     seam calls** for the search terms. (`emailVerified` cannot
+ *     appear: `eql_v3_boolean` is storage-only — see bool.e2e.test.ts.)
  *   - The query is a read so no row-write envelopes are encrypted.
  *   - The result rows carry encrypted values across six columns; a
  *     follow-up `decryptAll(rows)` produces **6 bulkDecrypt calls**
  *     (one per `(table, column)` group spanning the result set).
  */
 
-import { bulkEncryptMiddleware } from '@cipherstash/prisma-next/middleware'
 import {
-  cipherstashAsc,
-  createCipherstashRuntimeDescriptor,
+  bulkEncryptMiddlewareV3,
+  cipherstashV3Asc,
+  createCipherstashV3RuntimeDescriptor,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 import {
-  cipherstashFromStack,
-  createCipherstashSdk,
-  deriveStackSchemas,
-} from '@cipherstash/prisma-next/stack'
+  cipherstashFromStackV3,
+  createCipherstashV3Sdk,
+  deriveStackSchemasV3,
+} from '@cipherstash/prisma-next/v3'
 import postgres from '@prisma-next/postgres/runtime'
 import { and } from '@prisma-next/sql-orm-client'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
@@ -84,7 +86,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(s.email),
-    salary: EncryptedDouble.from(s.salary),
+    salary: EncryptedNumber.from(s.salary),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(s.birthday),
     emailVerified: EncryptedBoolean.from(s.emailVerified),
@@ -94,10 +96,10 @@ function seedRow(s: (typeof SEED)[number]) {
 
 /**
  * Build a counting wrapper around a base SDK so we can observe
- * `bulkEncrypt` / `bulkDecrypt` call counts independent of the
+ * `bulkEncrypt` / `bulkDecrypt` seam-call counts independent of the
  * harness's shared `db` instance.
  */
-function wrapWithCounting(base: ReturnType<typeof createCipherstashSdk>) {
+function wrapWithCounting(base: ReturnType<typeof createCipherstashV3Sdk>) {
   let bulkEncryptCalls = 0
   let bulkDecryptCalls = 0
   return {
@@ -127,8 +129,8 @@ function wrapWithCounting(base: ReturnType<typeof createCipherstashSdk>) {
   }
 }
 
-describe('Mixed-codec e2e (live PG + EQL + ZeroKMS)', () => {
-  // Use a private `db` instance with a counting SDK so the round-trip
+describe('Mixed-domain e2e (live PG + EQL v3 + ZeroKMS)', () => {
+  // Use a private `db` instance with a counting SDK so the crossing
   // assertions are insulated from any other test file that may have
   // mutated the harness's shared client.
   const url =
@@ -139,19 +141,19 @@ describe('Mixed-codec e2e (live PG + EQL + ZeroKMS)', () => {
   let runtime: { close(): Promise<void> } | undefined
 
   beforeAll(async () => {
-    // Reuse the encryption client from `cipherstashFromStack` so the
+    // Reuse the encryption client from `cipherstashFromStackV3` so the
     // counting wrapper observes the same ZeroKMS workspace + schema
-    // surface the example app would in production. Re-derive the stack
-    // schemas from `contractJson` to satisfy `createCipherstashSdk`'s
-    // `(client, schemas)` contract.
-    const { encryptionClient } = await cipherstashFromStack({ contractJson })
-    const schemas = deriveStackSchemas(contractJson)
-    const baseSdk = createCipherstashSdk(encryptionClient, schemas)
+    // surface the example app would in production. Re-derive the v3
+    // stack schemas from `contractJson` to satisfy
+    // `createCipherstashV3Sdk`'s `(client, schemas)` contract.
+    const { encryptionClient } = await cipherstashFromStackV3({ contractJson })
+    const schemas = deriveStackSchemasV3(contractJson)
+    const baseSdk = createCipherstashV3Sdk(encryptionClient, schemas)
     counting = wrapWithCounting(baseSdk)
     db = postgres<Contract>({
       contractJson,
-      extensions: [createCipherstashRuntimeDescriptor({ sdk: counting.sdk })],
-      middleware: [bulkEncryptMiddleware(counting.sdk)],
+      extensions: [createCipherstashV3RuntimeDescriptor({ sdk: counting.sdk })],
+      middleware: [bulkEncryptMiddlewareV3(counting.sdk)],
     })
     runtime = (await db.connect({ url })) as { close(): Promise<void> }
     await truncateUsers()
@@ -165,41 +167,41 @@ describe('Mixed-codec e2e (live PG + EQL + ZeroKMS)', () => {
     }
   })
 
-  it('executes a four-column WHERE + ordered read end-to-end', async () => {
+  it('executes a three-column WHERE + order-term read end-to-end', async () => {
     const rows = await db.orm.public.User.where((u) =>
       and(
-        u.email.cipherstashIlike('%@example.com'),
+        u.email.cipherstashIlike('example.com'),
         u.salary.cipherstashGt(75_000),
         u.birthday.cipherstashLt(new Date('2000-01-01')),
-        u.emailVerified.cipherstashInArray([true]),
       ),
     )
-      .orderBy((u) => cipherstashAsc(u.salary))
+      .orderBy((u) => cipherstashV3Asc(u.salary))
       .all()
 
-    // Only bob (e2e-mixed-1) survives all four predicates: alice's
-    // salary is below the 75k cutoff, carol is unverified, and
-    // dave's email `dave@otherorg.test` doesn't match `%@example.com`.
-    expect(rows.map((r) => r.id)).toEqual(['e2e-mixed-1'])
+    // carol (90k) and bob (110k) survive all three predicates, ordered
+    // by ascending encrypted salary; alice's salary is below the 75k
+    // cutoff and dave's email `dave@otherorg.test` carries no
+    // example.com token.
+    expect(rows.map((r) => r.id)).toEqual(['e2e-mixed-2', 'e2e-mixed-1'])
   })
 
-  it('groups search-term encrypts: one bulkEncrypt per (table, column)', async () => {
+  it('groups operand encrypts: one bulkEncrypt seam call per (table, column)', async () => {
     counting.counts.reset()
     await db.orm.public.User.where((u) =>
       and(
-        u.email.cipherstashIlike('%@example.com'),
+        u.email.cipherstashIlike('example.com'),
         u.salary.cipherstashGt(75_000),
         u.birthday.cipherstashLt(new Date('2000-01-01')),
-        u.emailVerified.cipherstashInArray([true]),
       ),
     )
-      .orderBy((u) => cipherstashAsc(u.salary))
+      .orderBy((u) => cipherstashV3Asc(u.salary))
       .all()
-    // Four distinct (users, <column>) groups in the WHERE — one
-    // `bulkEncrypt` round-trip per group. ORDER BY is a column ref
-    // (no envelope to encrypt). No row writes, so no additional
-    // bulk-encrypt calls beyond the search-term batches.
-    expect(counting.counts.bulkEncrypt).toBe(4)
+    // Three distinct (users, <column>) groups in the WHERE — one
+    // framework-SDK `bulkEncrypt` crossing per group (each routed to
+    // `encryptQuery` inside the v3 adapter). ORDER BY is an order-term
+    // extraction over the column itself (no operand to encrypt). No
+    // row writes, so no additional crossings.
+    expect(counting.counts.bulkEncrypt).toBe(3)
   })
 
   it('groups result decrypts: one bulkDecrypt per (table, column)', async () => {
diff --git a/examples/prisma/test/e2e/num.e2e.test.ts b/examples/prisma/test/e2e/num.e2e.test.ts
index 6b22eb7b..4a5366e2 100644
--- a/examples/prisma/test/e2e/num.e2e.test.ts
+++ b/examples/prisma/test/e2e/num.e2e.test.ts
@@ -1,18 +1,19 @@
 /**
- * End-to-end round-trip for `EncryptedDouble` against live
- * Postgres + EQL bundle + ZeroKMS.
+ * End-to-end round-trip for the `eql_v3_double_ord` domain against
+ * live Postgres + EQL v3 + ZeroKMS.
  *
  * Pins:
- *   - INSERT + decrypt round-trip recovers the source numbers.
+ *   - INSERT + decrypt round-trip recovers the source numbers (v3
+ *     `number`-castAs domains decrypt to the `EncryptedNumber`
+ *     envelope, not the v2 `EncryptedDouble`).
  *   - `cipherstashGt`, `cipherstashGte`, `cipherstashLt`,
  *     `cipherstashLte`, `cipherstashBetween` each filter rows
- *     correctly against the IEEE-754-encrypted column.
- *   - `cipherstashAsc` / `cipherstashDesc` produce numerically-
- *     sorted results via bare-column `ORDER BY` against the live
- *     EQL operator family. The cipherstash codec relies on the
- *     EQL bundle's overloads of `<` / `>` for `eql_v2_encrypted`,
- *     so an `ORDER BY <col>` clause sorts by the encrypted ORE
- *     value without requiring a wrapping helper.
+ *     correctly against the OPE-indexed encrypted column
+ *     (`eql_v3.gt(col, $n::eql_v3.query_double_ord)` and friends).
+ *   - `cipherstashV3Asc` / `cipherstashV3Desc` produce numerically
+ *     sorted results. Unlike v2's bare-column ORDER BY, v3 sorting
+ *     extracts the encrypted order term (`eql_v3.ord_term(col)`) —
+ *     the domain has no cross-row comparison operators of its own.
  *
  * Seed: four rows with file-scoped ID prefix `e2e-num-`. The
  * `beforeAll` truncates `users` first so the file's assertions
@@ -20,14 +21,14 @@
  */
 
 import {
-  cipherstashAsc,
-  cipherstashDesc,
+  cipherstashV3Asc,
+  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
@@ -44,7 +45,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(`${s.id}@example.com`),
-    salary: EncryptedDouble.from(s.salary),
+    salary: EncryptedNumber.from(s.salary),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(new Date('1990-01-01')),
     emailVerified: EncryptedBoolean.from(true),
@@ -52,14 +53,14 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedDouble e2e (live PG + EQL + ZeroKMS)', () => {
+describe('EncryptedNumber (eql_v3_double_ord) e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
     await Promise.all(SEED.map((s) => db.orm.public.User.create(seedRow(s))))
   })
 
-  it('round-trips an EncryptedDouble through bulkEncrypt + bulkDecrypt', async () => {
+  it('round-trips an EncryptedNumber through bulkEncrypt + bulkDecrypt', async () => {
     const rows = await db.orm.public.User.all()
     expect(rows).toHaveLength(SEED.length)
     await decryptAll(rows)
@@ -71,7 +72,7 @@ describe('EncryptedDouble e2e (live PG + EQL + ZeroKMS)', () => {
     }
   })
 
-  it('cipherstashGt filters by encrypted IEEE-754 numeric order', async () => {
+  it('cipherstashGt filters by encrypted numeric order', async () => {
     const rows = await db.orm.public.User.where((u) =>
       u.salary.cipherstashGt(95_000),
     ).all()
@@ -114,9 +115,9 @@ describe('EncryptedDouble e2e (live PG + EQL + ZeroKMS)', () => {
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-num-1', 'e2e-num-2'])
   })
 
-  it('cipherstashAsc orders by numeric value via bare-column ORDER BY', async () => {
+  it('cipherstashV3Asc orders by numeric value via the encrypted order term', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashAsc(u.salary),
+      cipherstashV3Asc(u.salary),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-num-0',
@@ -126,9 +127,9 @@ describe('EncryptedDouble e2e (live PG + EQL + ZeroKMS)', () => {
     ])
   })
 
-  it('cipherstashDesc reverses the ascending order', async () => {
+  it('cipherstashV3Desc reverses the ascending order', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashDesc(u.salary),
+      cipherstashV3Desc(u.salary),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-num-3',
diff --git a/examples/prisma/test/e2e/str-range.e2e.test.ts b/examples/prisma/test/e2e/str-range.e2e.test.ts
index e8d4e229..3a60152d 100644
--- a/examples/prisma/test/e2e/str-range.e2e.test.ts
+++ b/examples/prisma/test/e2e/str-range.e2e.test.ts
@@ -1,28 +1,29 @@
 /**
- * End-to-end round-trip for `EncryptedString` authored with
- * `orderAndRange: true` against live Postgres + EQL bundle +
- * ZeroKMS.
+ * End-to-end coverage for the `eql_v3_text_search` domain against
+ * live Postgres + EQL v3 + ZeroKMS.
  *
- * The example schema authors `email` with the default no-args
- * constructor (`cipherstash.EncryptedString()`), which opts every
- * flag (`equality`, `freeTextSearch`, `orderAndRange`) into `true`.
- * Pins:
+ * `cipherstash.EncryptedTextSearch()` is the maximal text domain:
+ * equality + order/range (OPE) + free-text search (bloom match) on one
+ * column. Pins:
+ *   - Round-trip decrypt recovers the source strings.
+ *   - `cipherstashEq` selects exactly the matching row.
  *   - `cipherstashGt('m')` filters lexicographically.
- *   - `cipherstashAsc(u.email)` orders alphabetically.
- *   - `cipherstashIlike('%@example.com')` still works alongside the
- *     range queries (free-text-search trait coexists with
- *     order-and-range on the same column).
+ *   - `cipherstashV3Asc` / `cipherstashV3Desc` order alphabetically
+ *     via the encrypted order term.
+ *   - `cipherstashIlike` — bloom-filter TOKEN containment
+ *     (`eql_v3.contains`), not SQL ILIKE — coexists with the
+ *     order-and-range operators on the same column.
  */
 
 import {
-  cipherstashAsc,
-  cipherstashDesc,
+  cipherstashV3Asc,
+  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
   EncryptedDate,
-  EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
@@ -39,7 +40,7 @@ function seedRow(s: (typeof SEED)[number]) {
   return {
     id: s.id,
     email: EncryptedString.from(s.email),
-    salary: EncryptedDouble.from(50_000),
+    salary: EncryptedNumber.from(50_000),
     accountId: EncryptedBigInt.from(1_000_000n),
     birthday: EncryptedDate.from(new Date('1990-01-01')),
     emailVerified: EncryptedBoolean.from(true),
@@ -47,7 +48,7 @@ function seedRow(s: (typeof SEED)[number]) {
   }
 }
 
-describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
+describe('EncryptedString (eql_v3_text_search) e2e (live PG + EQL v3 + ZeroKMS)', () => {
   beforeAll(async () => {
     await ensureConnected()
     await truncateUsers()
@@ -66,6 +67,13 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
     }
   })
 
+  it('cipherstashEq selects exactly the matching row', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.email.cipherstashEq('mallory@example.com'),
+    ).all()
+    expect(rows.map((r) => r.id)).toEqual(['e2e-str-2'])
+  })
+
   it('cipherstashGt filters lexicographically', async () => {
     const rows = await db.orm.public.User.where((u) =>
       u.email.cipherstashGt('m'),
@@ -73,9 +81,9 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-str-2', 'e2e-str-3'])
   })
 
-  it('cipherstashAsc orders alphabetically (bare-column ORDER BY on string)', async () => {
+  it('cipherstashV3Asc orders alphabetically via the encrypted order term', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashAsc(u.email),
+      cipherstashV3Asc(u.email),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-str-0',
@@ -85,9 +93,9 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
     ])
   })
 
-  it('cipherstashDesc reverses the alphabetical order', async () => {
+  it('cipherstashV3Desc reverses the alphabetical order', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashDesc(u.email),
+      cipherstashV3Desc(u.email),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-str-3',
@@ -97,9 +105,9 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
     ])
   })
 
-  it('cipherstashIlike coexists with order-and-range on the same column', async () => {
+  it('cipherstashIlike (bloom token containment) coexists with order-and-range', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.email.cipherstashIlike('%@example.com'),
+      u.email.cipherstashIlike('example.com'),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-str-0',
@@ -107,4 +115,11 @@ describe('EncryptedString orderAndRange e2e (live PG + EQL + ZeroKMS)', () => {
       'e2e-str-2',
     ])
   })
+
+  it('cipherstashIlike misses tokens absent from the ciphertext index', async () => {
+    const rows = await db.orm.public.User.where((u) =>
+      u.email.cipherstashIlike('nonexistent-token'),
+    ).all()
+    expect(rows).toHaveLength(0)
+  })
 })

From 3f5666794d6ec16d68b6f0ff12101c98e381642d Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Thu, 16 Jul 2026 16:57:56 -0600
Subject: [PATCH 14/21] refactor(prisma-next): consume
 @cipherstash/stack/adapter-kit, drop the eql/v3 graduation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The branch had graduated DOMAIN_REGISTRY / factoryForDomain /
stripDomainSchema onto the public eql/v3 barrel while adapter-kit still
exported the same symbols — two doors to one registry. Revert the
graduation and import through adapter-kit, the seam the Drizzle and
Supabase adapters already consume (PR #655 review, item 3). Also make
v3Authored return a fresh descriptor per invocation so a caller
mutation cannot alter later contracts (review).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../eql-v3-stack-domain-registry-exports.md   |  9 ----
 .../prisma-next/src/exports/column-types.ts   | 43 +++++++++++--------
 packages/prisma-next/src/v3/catalog.ts        | 10 +++--
 .../test/v3/catalog-invariants.test.ts        |  5 ++-
 packages/stack/src/eql/v3/index.ts            |  6 ---
 5 files changed, 36 insertions(+), 37 deletions(-)
 delete mode 100644 .changeset/eql-v3-stack-domain-registry-exports.md

diff --git a/.changeset/eql-v3-stack-domain-registry-exports.md b/.changeset/eql-v3-stack-domain-registry-exports.md
deleted file mode 100644
index dfc68d03..00000000
--- a/.changeset/eql-v3-stack-domain-registry-exports.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-'@cipherstash/stack': minor
----
-
-Export `DOMAIN_REGISTRY`, `factoryForDomain`, `stripDomainSchema`, and the
-`V3ColumnFactory` type from `@cipherstash/stack/eql/v3`. These let integration
-adapters (e.g. `@cipherstash/prisma-next`) derive the full EQL v3 domain
-catalog — native types, capabilities, cast kinds, and indexes — from the stack
-instead of hand-maintaining a copy.
diff --git a/packages/prisma-next/src/exports/column-types.ts b/packages/prisma-next/src/exports/column-types.ts
index f97bc49c..dfb152d3 100644
--- a/packages/prisma-next/src/exports/column-types.ts
+++ b/packages/prisma-next/src/exports/column-types.ts
@@ -25,11 +25,12 @@
  * `AuthoringArgRef.default`.
  */
 
-import {
-  type AnyEncryptedV3Column,
-  stripDomainSchema,
-  types,
-} from '@cipherstash/stack/eql/v3'
+// `stripDomainSchema` is adapter-seam surface (`adapter-kit`), same import
+// route as the Drizzle and Supabase adapters; `types` and the column union
+// stay on the public authoring entry.
+import { stripDomainSchema } from '@cipherstash/stack/adapter-kit'
+import type { AnyEncryptedV3Column } from '@cipherstash/stack/eql/v3'
+import { types } from '@cipherstash/stack/eql/v3'
 import {
   CIPHERSTASH_BIGINT_CODEC_ID,
   CIPHERSTASH_BOOLEAN_CODEC_ID,
@@ -97,19 +98,25 @@ function v3Authored<C extends AnyEncryptedV3Column>(
 ): () => V3ColumnDescriptor<C> {
   const probe = make('__probe__')
   const nativeType = probe.getEqlType()
-  const descriptor = {
-    codecId: toV3CodecId(stripDomainSchema(nativeType)),
-    nativeType,
-    typeParams: {
-      // Narrowing assertion, mirrors ../v3/catalog.ts: `build()` widens
-      // `cast_as` in the bundled d.ts; the value is the domain's literal.
-      castAs: probe.build().cast_as as V3CastAs,
-      capabilities: probe.getQueryCapabilities(),
-    },
-    // Narrowing assertion: runtime strings are the literals the getters
-    // declare; `toV3CodecId` returns `string` by signature.
-  } as V3ColumnDescriptor<C>
-  return () => descriptor
+  const codecId = toV3CodecId(stripDomainSchema(nativeType))
+  // Narrowing assertion, mirrors ../v3/catalog.ts: `build()` widens
+  // `cast_as` in the bundled d.ts; the value is the domain's literal.
+  const castAs = probe.build().cast_as as V3CastAs
+  const capabilities = probe.getQueryCapabilities()
+  // A FRESH descriptor per invocation: descriptors flow into caller-owned
+  // contract structures, so a shared instance would let one caller's
+  // mutation alter every later contract (call-order-dependent output).
+  return () =>
+    ({
+      codecId,
+      nativeType,
+      typeParams: {
+        castAs,
+        capabilities: { ...capabilities },
+      },
+      // Narrowing assertion: runtime strings are the literals the getters
+      // declare; `toV3CodecId` returns `string` by signature.
+    }) as V3ColumnDescriptor<C>
 }
 
 // Each factory has a DISTINCT return type (V3ColumnDescriptor<EncryptedXColumn>);
diff --git a/packages/prisma-next/src/v3/catalog.ts b/packages/prisma-next/src/v3/catalog.ts
index 5bb6b3fa..9c677927 100644
--- a/packages/prisma-next/src/v3/catalog.ts
+++ b/packages/prisma-next/src/v3/catalog.ts
@@ -10,12 +10,16 @@
  * prettified transform decode would have to invert. The `eql-v3` token is a
  * logical version tag, NOT the operator schema.
  */
+// The registry is adapter-seam surface (`adapter-kit`), consumed here the same
+// way the Drizzle and Supabase adapters consume it; the public `eql/v3` entry
+// stays end-user authoring API only (see stack's `adapter-kit.ts` header).
 import {
   type AnyEncryptedV3Column,
   DOMAIN_REGISTRY,
-  type QueryCapabilities,
-  type V3ColumnFactory,
-} from '@cipherstash/stack/eql/v3'
+} from '@cipherstash/stack/adapter-kit'
+import type { QueryCapabilities } from '@cipherstash/stack/eql/v3'
+
+type V3ColumnFactory = (name: string) => AnyEncryptedV3Column
 
 export type V3CastAs =
   | 'string'
diff --git a/packages/prisma-next/test/v3/catalog-invariants.test.ts b/packages/prisma-next/test/v3/catalog-invariants.test.ts
index ce6e324b..e5971a4f 100644
--- a/packages/prisma-next/test/v3/catalog-invariants.test.ts
+++ b/packages/prisma-next/test/v3/catalog-invariants.test.ts
@@ -1,4 +1,7 @@
-import { DOMAIN_REGISTRY } from '@cipherstash/stack/eql/v3'
+// The domain registry is adapter-seam surface: the eql/v3 barrel no
+// longer exports it, so it ships from adapter-kit (the same import
+// route `src/v3/catalog.ts` uses).
+import { DOMAIN_REGISTRY } from '@cipherstash/stack/adapter-kit'
 import { describe, expect, it } from 'vitest'
 import {
   EXPOSED_DOMAIN_ENTRIES,
diff --git a/packages/stack/src/eql/v3/index.ts b/packages/stack/src/eql/v3/index.ts
index b46b43c1..62013292 100644
--- a/packages/stack/src/eql/v3/index.ts
+++ b/packages/stack/src/eql/v3/index.ts
@@ -62,12 +62,6 @@ export {
   EncryptedTimestampOrdOreColumn,
   TEXT_SEARCH_EQL_TYPE,
 } from './columns'
-export {
-  DOMAIN_REGISTRY,
-  factoryForDomain,
-  stripDomainSchema,
-  type V3ColumnFactory,
-} from './domain-registry'
 export type {
   AnyV3Table,
   ColumnsOf,

From 94b54fe8267b43cd8b43d1ae1724b2eb9ab551c9 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Thu, 16 Jul 2026 16:58:19 -0600
Subject: [PATCH 15/21] feat(prisma-next): EQL-derived v3 operator vocabulary
 with a guarded eqlMatch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rename the v3 query operations to the eql_v3.* function vocabulary they
lower to — eqlEq/eqlNeq/eqlIn/eqlNotIn/eqlGt/eqlGte/eqlLt/eqlLte/
eqlBetween/eqlNotBetween/eqlJsonContains, ordering via eqlAsc/eqlDesc.
The eql prefix (not bare eq/gt) is required because the framework's
native scope-field methods already claim eq/neq/gt/…, which lower to
plain SQL comparisons (PR #655 review, items 1+2). The v2 surface keeps
its cipherstash* names; the sets are now disjoint.

Free-text search is eqlMatch, not ilike: eql_v3.contains is fuzzy bloom
token matching, not SQL pattern semantics. Two guards run before
encryption: wildcard normalisation (leading/trailing % stripped,
interior % or any _ rejected) and the shared adapter-kit
matchNeedleError short-needle rejection. cipherstashNotIlike is removed
outright — negating a may-false-positive bloom test silently drops
matching rows.

Type-level dispatch mirrors the split: v3 codec entries carry only
cipherstash:v3-* marker traits, so eql* methods never surface on v2
columns and cipherstash* methods never surface on v3 columns.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/eql-v3-prisma-next.md              |   7 +-
 packages/prisma-next/README.md                |   7 +-
 packages/prisma-next/src/exports/runtime.ts   |   4 +-
 packages/prisma-next/src/exports/v3.ts        |   4 +-
 packages/prisma-next/src/types/codec-types.ts |  42 +--
 .../prisma-next/src/types/operation-types.ts  | 143 +++++++---
 packages/prisma-next/src/v3/operators-v3.ts   | 248 ++++++++++++------
 packages/prisma-next/src/v3/runtime-v3.ts     |  10 +-
 .../prisma-next/test/column-types.test.ts     |  34 +++
 .../test/operation-types.types.test-d.ts      | 163 ++++++++----
 .../test/v3/bulk-encrypt-v3.test.ts           |  38 ++-
 .../test/v3/codec-types-v3.test-d.ts          |  42 +--
 .../test/v3/operator-gating-v3.test.ts        | 100 +++----
 .../v3/operator-lowering-v3-equality.test.ts  |  44 ++--
 .../test/v3/operator-lowering-v3-json.test.ts |  22 +-
 .../operator-lowering-v3-order-range.test.ts  |  40 ++-
 .../operator-lowering-v3-text-search.test.ts  | 153 ++++++++---
 .../test/v3/operator-lowering-v3.helpers.ts   |   8 +-
 .../prisma-next/test/v3/properties.test.ts    |  47 ++--
 .../prisma-next/test/v3/runtime-v3.test.ts    |   4 +-
 20 files changed, 767 insertions(+), 393 deletions(-)

diff --git a/.changeset/eql-v3-prisma-next.md b/.changeset/eql-v3-prisma-next.md
index c845f5a7..3d29dc32 100644
--- a/.changeset/eql-v3-prisma-next.md
+++ b/.changeset/eql-v3-prisma-next.md
@@ -8,15 +8,16 @@
   - Text: `EncryptedText` (storage), `EncryptedTextEq`, `EncryptedTextOrd` (eq + order/range), `EncryptedTextMatch` (free-text), `EncryptedTextSearch` (eq + free-text + order/range).
   - Scalars (Integer, Smallint, BigInt, Numeric, Real, Double, Date, Timestamp): `Encrypted<Fam>` (storage), `Encrypted<Fam>Eq`, `Encrypted<Fam>Ord`.
   - `EncryptedBoolean` — storage-only (`public.eql_v3_boolean`); there is no boolean equality constructor.
-  - `EncryptedJson` — searchable encrypted JSONB (`public.eql_v3_json`, `ste_vec`), queried with `cipherstashJsonContains` (`@>` containment).
+  - `EncryptedJson` — searchable encrypted JSONB (`public.eql_v3_json`, `ste_vec`), queried with `eqlJsonContains` (`@>` containment). Selector querying (comparing the value at a JSONPath) is tracked in #677.
 - **Impossible capability combinations have no constructor** (e.g. text equality + free-text without order/range) — they are unrepresentable, not runtime errors.
 - **BigInt is a first-class v3 family** (`EncryptedBigInt` / `EncryptedBigIntEq` / `EncryptedBigIntOrd`, JS `bigint` plaintext, backed by `public.eql_v3_bigint*`).
 - Use the `*V2` constructors (`EncryptedStringV2`, `EncryptedDoubleV2`, `EncryptedBigIntV2`, `EncryptedDateV2`, `EncryptedBooleanV2`, `EncryptedJsonV2`) to keep EQL v2 columns. A client is v2 or v3 — the two runtime descriptors are never co-registered.
 - New `@cipherstash/prisma-next/v3` entry point: `cipherstashFromStackV3({ contractJson })` builds the v3 runtime descriptor, bulk-encrypt middleware, and a stack `EncryptionV3` client from the emitted contract.
-- Query operators (`cipherstashEq`, `cipherstashGt`, `cipherstashBetween`, `cipherstashInArray`, …) lower to `eql_v3.*` functions with operands cast to the domain's query type (`$n::eql_v3.query_<domain>`); `cipherstashIlike` maps to `eql_v3.contains` (bloom-filter token containment, not SQL `LIKE`); ordering uses `eql_v3.ord_term` / `eql_v3.ord_term_ore` by the column's ordering flavour. The domains are `public.eql_v3_*`; the operator functions live in the `eql_v3` schema.
+- Query operators use an **EQL-derived vocabulary** (`eqlEq`, `eqlNeq`, `eqlIn`, `eqlNotIn`, `eqlGt`, `eqlGte`, `eqlLt`, `eqlLte`, `eqlBetween`, `eqlNotBetween`, `eqlJsonContains`; ordering via `eqlAsc` / `eqlDesc`), lowering to the same-named `eql_v3.*` functions with operands cast to the domain's query type (`$n::eql_v3.query_<domain>`); ordering uses `eql_v3.ord_term` / `eql_v3.ord_term_ore` by the column's ordering flavour. The domains are `public.eql_v3_*`; the operator functions live in the `eql_v3` schema. (The v2 surface keeps its `cipherstash*` names.)
+- Free-text search is **`eqlMatch`** — fuzzy bloom token matching (`eql_v3.contains`), deliberately NOT named after SQL `ILIKE`: matching is case-insensitive, order/multiplicity-insensitive, and one-sided (may false-positive). Two guards run before encryption: SQL wildcards are normalised (leading/trailing `%` stripped; interior `%` or any `_` rejected), and needles the column's match index cannot answer (empty / below the tokenizer length) are rejected via the shared `matchNeedleError` guard. There is **no negated match operator** — negating a may-false-positive bloom test would silently drop matching rows.
 - A new baseline migration `20260601T0100_install_eql_v3_bundle` (invariant `cipherstash:install-eql-v3-bundle-v1`) installs the `public.eql_v3_*` domains and `eql_v3.*` functions from the pinned `@cipherstash/eql` release. Regenerate contracts and run migrations after changing constructors.
 - **The v3 ORM surface is fully wired end-to-end** (proven by converting `examples/prisma`):
-  - The generated `contract.d.ts` type surface covers every v3 codec id: `CodecTypes` gains all 40 `cipherstash/eql-v3/*@1` entries (envelope outputs — `number`-castAs domains decode to the new `EncryptedNumber` — plus trait-accurate operator visibility), and `QueryOperationTypes` gains `cipherstashJsonContains` and surfaces `cipherstashEq` / `cipherstashIlike` on v3 columns via type-level `cipherstash:v3-*` marker traits. Storage-only domains (including `EncryptedBoolean`) surface no operator methods at the type level, matching the runtime gate.
+  - The generated `contract.d.ts` type surface covers every v3 codec id: `CodecTypes` gains all 40 `cipherstash/eql-v3/*@1` entries (envelope outputs — `number`-castAs domains decode to the new `EncryptedNumber` — plus trait-accurate operator visibility), and `QueryOperationTypes` gains the `eql*` operator set, surfaced on v3 columns via type-level `cipherstash:v3-*` marker traits (the v2 `cipherstash*` methods never appear on v3 columns, and vice-versa). Storage-only domains (including `EncryptedBoolean`) surface no operator methods at the type level, matching the runtime gate.
   - The v3 runtime descriptor now presents the **pack id** (`cipherstash`) with v3's own version, so `postgres<Contract>({ extensions })` accepts contracts emitted by the cipherstash extension pack instead of failing with `RUNTIME.MISSING_EXTENSION_PACK`.
   - Every v3 codec id registers a control-plane `expandNativeType` hook that strips the `public.` qualifier — `prisma-next migration plan` now renders `CREATE TABLE` columns as bare domain names (`eql_v3_bigint_ord`), matching what introspection reports, with **no `add_search_config` ops** (v3 domains carry their own index metadata). No `onFieldEvent` is registered for v3.
   - The v3 bundle baseline migration op is reclassified `data` (it is a contract-shape-neutral self-edge; the aggregate integrity checker rejects self-edges without a data-class op), unblocking `prisma-next migration plan` / `migrate` in consuming apps.
diff --git a/packages/prisma-next/README.md b/packages/prisma-next/README.md
index 6795240c..9bf21482 100644
--- a/packages/prisma-next/README.md
+++ b/packages/prisma-next/README.md
@@ -10,9 +10,9 @@ Declare encrypted columns directly in `schema.prisma`, and the framework's migra
 
 - 🔒 Six encrypted column types — `string`, `double`, `bigint`, `date`, `boolean`, `json`
 - 🔍 Searchable encryption — equality, free-text search, range, order, JSON path and containment
-- 🎯 17 type-safe query operators (`cipherstashEq`, `cipherstashIlike`, `cipherstashGt`, `cipherstashAsc`, …)
+- 🎯 Type-safe query operators — EQL v3 uses the EQL-derived `eql*` vocabulary (`eqlEq`, `eqlMatch`, `eqlGt`, `eqlAsc`, …); the legacy v2 surface keeps its `cipherstash*` names
 - ⚡ Bulk encrypt / bulk decrypt coalescing — one SDK round-trip per `(table, column)` group per query
-- 🧩 One-call setup via `cipherstashFromStack({ contractJson })` — no duplicate stack schema to maintain
+- 🧩 One-call setup via `cipherstashFromStackV3({ contractJson })` (v2: `cipherstashFromStack`) — no duplicate stack schema to maintain
 - 🛡️ Plaintext redaction on every implicit serialisation path (`toJSON`, `toString`, `util.inspect`, …)
 
 ## Installation
@@ -91,7 +91,8 @@ See the [full documentation](https://cipherstash.com/docs/stack/cipherstash/encr
 
 | Subpath          | Purpose                                                                                                |
 | ---------------- | ------------------------------------------------------------------------------------------------------ |
-| `./stack`        | One-call setup against `@cipherstash/stack`: `cipherstashFromStack`, `deriveStackSchemas`, `createCipherstashSdk` |
+| `./v3`           | The complete EQL v3 surface: `cipherstashFromStackV3`, the `eql*` query operations, `eqlAsc`/`eqlDesc`, envelopes, middleware, SDK adapter |
+| `./stack`        | One-call setup against `@cipherstash/stack` (EQL v2): `cipherstashFromStack`, `deriveStackSchemas`, `createCipherstashSdk` |
 | `./control`      | `SqlControlExtensionDescriptor` (contract space + pack meta + codec lifecycle hooks)                   |
 | `./runtime`      | Six envelope classes + `CipherstashSdk` + codec runtime + `decryptAll` + four free-standing helpers    |
 | `./middleware`   | `bulkEncryptMiddleware(sdk)`                                                                           |
diff --git a/packages/prisma-next/src/exports/runtime.ts b/packages/prisma-next/src/exports/runtime.ts
index 18d957d6..32f11097 100644
--- a/packages/prisma-next/src/exports/runtime.ts
+++ b/packages/prisma-next/src/exports/runtime.ts
@@ -146,9 +146,9 @@ export type {
 } from '../v3/envelope-number'
 export { EncryptedNumber } from '../v3/envelope-number'
 export {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   cipherstashV3QueryOperations,
+  eqlAsc,
+  eqlDesc,
 } from '../v3/operators-v3'
 export {
   EncryptionOperatorError,
diff --git a/packages/prisma-next/src/exports/v3.ts b/packages/prisma-next/src/exports/v3.ts
index 779522fc..c829acc6 100644
--- a/packages/prisma-next/src/exports/v3.ts
+++ b/packages/prisma-next/src/exports/v3.ts
@@ -57,9 +57,9 @@ export { assertV3SchemasAgree } from '../v3/from-stack-v3-validate'
 // Query operators (registered by the runtime descriptor) + the
 // free-standing ORDER BY helpers.
 export {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   cipherstashV3QueryOperations,
+  eqlAsc,
+  eqlDesc,
 } from '../v3/operators-v3'
 // The query-term seam (consumed by custom CipherstashSdk implementations).
 export {
diff --git a/packages/prisma-next/src/types/codec-types.ts b/packages/prisma-next/src/types/codec-types.ts
index d2629803..d20437a4 100644
--- a/packages/prisma-next/src/types/codec-types.ts
+++ b/packages/prisma-next/src/types/codec-types.ts
@@ -59,42 +59,24 @@ import type { EncryptedNumber } from '../v3/envelope-number'
 // EQL v3 type-level trait vocabulary
 // ---------------------------------------------------------------------------
 //
-// The SHARED trait strings (`cipherstash:equality`, `cipherstash:
-// order-and-range`, `cipherstash:free-text-search`) appear on v3
-// entries exactly like on v2 entries: the trait-dispatched operator
-// methods (`cipherstashNe`, `cipherstashGt`, `cipherstashBetween`, …)
-// exist in BOTH runtime generations under the same names (decision 1b
-// keeps the method-name surface identical), so sharing the dispatch
-// trait is correct.
-//
 // The `cipherstash:v3-*` strings are TYPE-LEVEL MARKERS with no
-// runtime counterpart. They exist because three methods differ by
-// generation:
+// runtime counterpart. The v2 and v3 surfaces have DISJOINT method
+// names (`cipherstash*` vs the EQL-derived `eql*` — PR #655 review),
+// so v3 codec entries carry ONLY the v3 markers and none of the shared
+// v2 trait strings:
 //
-//   - `cipherstashEq` / `cipherstashIlike` are codec-id-pinned to
-//     `cipherstash/string@1` in the v2 runtime (legacy single-codec
-//     registration) but trait-dispatched in the v3 runtime. Their
-//     type-level `self` in `operation-types.ts` therefore declares
-//     BOTH a `codecId` (matched for v2 string columns) and a
-//     `traits: ['cipherstash:v3-equality' / 'cipherstash:v3-free-
-//     text-search']` marker (matched for v3 columns) — the
-//     framework's `OpMatchesField` tries codec-id first and falls
-//     through to traits.
-//   - `cipherstashJsonContains` exists ONLY in the v3 runtime, and
-//     `cipherstashJsonbPathExists` ONLY in the v2 runtime. The v3
-//     JSON entry deliberately carries `cipherstash:v3-searchable-json`
-//     INSTEAD of the shared `cipherstash:searchable-json` so each
-//     method surfaces only on the generation whose runtime registers
-//     it.
+//   - every `eql*` operator in `operation-types.ts` dispatches on a
+//     v3 marker, so it surfaces only on v3 columns;
+//   - every v2 operator dispatches on a shared v2 trait (or the legacy
+//     `cipherstash/string@1` codec-id pin), which no v3 entry carries,
+//     so the `cipherstash*` methods never surface on v3 columns.
 //
 // Type-level visibility therefore never advertises a method the
 // column's runtime cannot dispatch.
 type V3TraitsNone = never
-type V3TraitsEq = 'cipherstash:equality' | 'cipherstash:v3-equality'
-type V3TraitsOrd = V3TraitsEq | 'cipherstash:order-and-range'
-type V3TraitsMatch =
-  | 'cipherstash:free-text-search'
-  | 'cipherstash:v3-free-text-search'
+type V3TraitsEq = 'cipherstash:v3-equality'
+type V3TraitsOrd = V3TraitsEq | 'cipherstash:v3-order-and-range'
+type V3TraitsMatch = 'cipherstash:v3-free-text-search'
 type V3TraitsSearch = V3TraitsOrd | V3TraitsMatch
 type V3TraitsJson = 'cipherstash:v3-searchable-json'
 
diff --git a/packages/prisma-next/src/types/operation-types.ts b/packages/prisma-next/src/types/operation-types.ts
index 2069b927..e8cc77ae 100644
--- a/packages/prisma-next/src/types/operation-types.ts
+++ b/packages/prisma-next/src/types/operation-types.ts
@@ -8,7 +8,7 @@
  *
  *   - Single-codec entries (`cipherstashEq`, `cipherstashIlike`,
  *     `cipherstashNotIlike`, `cipherstashJsonbPathExists`) declare
- *     `self: { codecId: '<id>' }`. The framework's `OpMatchesField`
+ *     `self: { codecId: '<id>' }` (v2 legacy registrations). The framework's `OpMatchesField`
  *     direct-codec-id branch surfaces the method on columns whose
  *     codec id is the literal — no consumer-side `CodecTypes`
  *     augmentation needed.
@@ -86,15 +86,14 @@ type SearchableJsonTraits = readonly ['cipherstash:searchable-json']
 /**
  * v3 TYPE-LEVEL marker traits (no runtime counterpart) — carried only
  * by the v3 codec entries in `codec-types.ts` (see the vocabulary
- * comment there). Three methods differ by runtime generation:
- * `cipherstashEq` / `cipherstashIlike` are codec-id-pinned legacy
- * registrations in v2 but trait-dispatched in v3, and
- * `cipherstashJsonContains` (v3) / `cipherstashJsonbPathExists` (v2)
- * exist in only one generation each. Dispatching those on the marker
- * traits keeps type-level visibility exactly aligned with what each
- * column's runtime can actually execute.
+ * comment there). The v2 and v3 surfaces have DISJOINT method names
+ * (`cipherstash*` vs the EQL-derived `eql*`), so every v3 operator
+ * dispatches on a v3 marker and every v2 operator on the shared v2
+ * trait (or legacy codec-id pin) — type-level visibility stays exactly
+ * aligned with what each column's runtime can actually execute.
  */
 type V3EqualityMarker = readonly ['cipherstash:v3-equality']
+type V3OrderAndRangeMarker = readonly ['cipherstash:v3-order-and-range']
 type V3FreeTextSearchMarker = readonly ['cipherstash:v3-free-text-search']
 type V3SearchableJsonMarker = readonly ['cipherstash:v3-searchable-json']
 
@@ -138,31 +137,22 @@ type AnyExpressionLike = Expression<{
 export type QueryOperationTypes<CT extends CodecTypesBase> =
   CT extends CodecTypesBase
     ? {
-        // `self` carries BOTH dispatch forms: `OpMatchesField` tries the
-        // codec-id branch first (matches the v2 legacy single-codec
-        // registration on `cipherstash/string@1`) and falls through to
-        // the traits branch (matches v3 columns via the type-level
-        // `cipherstash:v3-*` markers). v2 non-string columns match
-        // neither — their runtime has no `cipherstashEq` to dispatch.
-        // The comparand is `unknown` (not `pg/text@1`) because v3
-        // equality spans every equality-capable domain family (bigint,
-        // date, numeric, …), and the runtime coerces + encrypts the
-        // operand per the column's castAs.
+        // -------------------------------------------------------------
+        // v2 legacy surface (`cipherstash*`). `cipherstashEq` /
+        // `cipherstashIlike` are codec-id-pinned to the v2 string codec
+        // (legacy single-codec registrations); the rest dispatch on the
+        // shared v2 traits, which v3 codec entries no longer carry —
+        // so none of these surface on a v3 column.
+        // -------------------------------------------------------------
         readonly cipherstashEq: {
-          readonly self: {
-            readonly codecId: CipherstashStringCodec
-            readonly traits: V3EqualityMarker
-          }
+          readonly self: { readonly codecId: CipherstashStringCodec }
           readonly impl: (
             self: AnyExpressionLike,
             other: unknown,
           ) => PgBoolReturn
         }
         readonly cipherstashIlike: {
-          readonly self: {
-            readonly codecId: CipherstashStringCodec
-            readonly traits: V3FreeTextSearchMarker
-          }
+          readonly self: { readonly codecId: CipherstashStringCodec }
           readonly impl: (
             self: AnyExpressionLike,
             pattern: CodecExpression<'pg/text@1', boolean, CT>,
@@ -244,13 +234,102 @@ export type QueryOperationTypes<CT extends CodecTypesBase> =
           readonly self: { readonly traits: SearchableJsonTraits }
           readonly impl: (self: AnyExpressionLike, path: string) => PgBoolReturn
         }
+        // -------------------------------------------------------------
+        // v3 surface (`eql*`, EQL-derived vocabulary — PR #655 review).
+        // Every entry dispatches on a `cipherstash:v3-*` marker, which
+        // only v3 codec entries carry, so nothing here surfaces on a
+        // v2 column (whose runtime has no `eql*` method to dispatch) —
+        // and, symmetrically, the v2 entries above never surface on v3
+        // columns. The comparand is `unknown` because each operator
+        // spans every capable domain family (bigint, date, numeric, …)
+        // and the runtime coerces + encrypts per the column's castAs.
+        // -------------------------------------------------------------
+        readonly eqlEq: {
+          readonly self: { readonly traits: V3EqualityMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlNeq: {
+          readonly self: { readonly traits: V3EqualityMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlIn: {
+          readonly self: { readonly traits: V3EqualityMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            values: readonly unknown[],
+          ) => PgBoolReturn
+        }
+        readonly eqlNotIn: {
+          readonly self: { readonly traits: V3EqualityMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            values: readonly unknown[],
+          ) => PgBoolReturn
+        }
+        readonly eqlGt: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlGte: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlLt: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlLte: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            other: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlBetween: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            low: unknown,
+            high: unknown,
+          ) => PgBoolReturn
+        }
+        readonly eqlNotBetween: {
+          readonly self: { readonly traits: V3OrderAndRangeMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            low: unknown,
+            high: unknown,
+          ) => PgBoolReturn
+        }
+        // Fuzzy free-text token match (`eql_v3.contains`) — NOT SQL
+        // pattern matching; needles are guarded at lowering time
+        // (wildcards, short needles). No negated form: the bloom test
+        // may false-positive, so its negation would false-negative.
+        readonly eqlMatch: {
+          readonly self: { readonly traits: V3FreeTextSearchMarker }
+          readonly impl: (
+            self: AnyExpressionLike,
+            needle: unknown,
+          ) => PgBoolReturn
+        }
         // v3-only: encrypted jsonb `@>` containment on `eql_v3_json`
-        // columns. Dispatches on the v3 marker trait (NOT the shared
-        // `cipherstash:searchable-json`) so it never surfaces on v2
-        // JSON columns, whose runtime does not register the method —
-        // and, symmetrically, `cipherstashJsonbPathExists` above never
-        // surfaces on v3 columns.
-        readonly cipherstashJsonContains: {
+        // columns.
+        readonly eqlJsonContains: {
           readonly self: { readonly traits: V3SearchableJsonMarker }
           readonly impl: (
             self: AnyExpressionLike,
diff --git a/packages/prisma-next/src/v3/operators-v3.ts b/packages/prisma-next/src/v3/operators-v3.ts
index a7d0f93c..5937844d 100644
--- a/packages/prisma-next/src/v3/operators-v3.ts
+++ b/packages/prisma-next/src/v3/operators-v3.ts
@@ -4,11 +4,11 @@
  * (`packages/stack-drizzle/src/v3/{operators,sql-dialect}.ts` is the
  * byte-for-byte reference):
  *
- *     eql_v3.eq(<col>, $n::eql_v3.query_<domain>)      -- equality
- *     eql_v3.gt(<col>, $n::eql_v3.query_<domain>)      -- comparison
- *     eql_v3.contains(<col>, $n::eql_v3.query_<domain>) -- bloom free-text
- *     <col> OPERATOR(public.@>) $n::eql_v3.query_jsonb  -- JSON containment
- *     eql_v3.ord_term(<col>) / eql_v3.ord_term_ore(<col>) -- ordering
+ *     eql_v3.eq(<col>, $n::eql_v3.query_<domain>)      -- equality (eqlEq)
+ *     eql_v3.gt(<col>, $n::eql_v3.query_<domain>)      -- comparison (eqlGt)
+ *     eql_v3.contains(<col>, $n::eql_v3.query_<domain>) -- bloom free-text (eqlMatch)
+ *     <col> OPERATOR(public.@>) $n::eql_v3.query_jsonb  -- JSON containment (eqlJsonContains)
+ *     eql_v3.ord_term(<col>) / eql_v3.ord_term_ore(<col>) -- ordering (eqlAsc/eqlDesc)
  *
  * ## Operands are QUERY TERMS, not storage envelopes
  *
@@ -55,17 +55,25 @@
  * derivation-time metadata, while a caller can reach a descriptor's
  * `impl` through a custom builder with any column expression.
  *
- * ## v2/v3 method-name identity (decision 1b)
+ * ## v3 method names are EQL-derived (`eql*`), not `cipherstash*`
  *
- * The registered method names (`cipherstashEq`, `cipherstashGt`, …)
- * are IDENTICAL to the v2 set — safe because the v2 and v3 runtime
- * descriptors are separate entry points that are never co-registered
- * (the flat `OperationRegistry` would throw on the shared names;
- * pinned in `test/v3/operator-gating-v3.test.ts`). This module imports
- * NO v2 codec/wire code — only the version-neutral envelope classes
- * and the shared trait constants.
+ * The registered method names (`eqlEq`, `eqlGt`, `eqlMatch`, …) derive
+ * from the `eql_v3.*` SQL functions they lower to, so the TS surface,
+ * the SQL, and the EQL docs share one vocabulary (PR #655 review). The
+ * `eql` prefix (rather than the bare `eq`/`gt`) is required: the
+ * framework's native scope-field methods already claim `eq`, `neq`,
+ * `gt`, `gte`, `lt`, `lte`, `in`, `notIn`, `like`, and those lower to
+ * plain SQL comparisons — wrong for EQL ciphertexts. The v2 surface
+ * keeps its historical `cipherstash*` names; the sets are disjoint, so
+ * the v2 and v3 descriptors no longer share any registry key (the
+ * never-co-registered stance of decision 1b still holds — a client is
+ * v2 or v3 by construction, pinned in
+ * `test/v3/operator-gating-v3.test.ts`). This module imports NO v2
+ * codec/wire code — only the version-neutral envelope classes and the
+ * shared trait constants.
  */
 
+import { matchNeedleError } from '@cipherstash/stack/adapter-kit'
 import type { CodecTrait } from '@prisma-next/framework-components/codec'
 import type {
   SqlOperationDescriptor,
@@ -175,7 +183,7 @@ function requireSelfCodec(
     throw new EncryptionOperatorError(
       `cipherstash ${method}: self expression is missing a CodecRef. ` +
         'Cipherstash predicate operators require a column-bound self argument; ' +
-        'reach the operator through the ORM model-accessor (e.g. `model.users.where((u) => u.email.cipherstashEq(...))`).',
+        'reach the operator through the ORM model-accessor (e.g. `model.users.where((u) => u.email.eqlEq(...))`).',
       { operator: method },
     )
   }
@@ -438,7 +446,7 @@ function fixedArityOperator(
 
 /**
  * Build a variable-arity v3 membership operator
- * (`cipherstashInArray` / `cipherstashNotInArray`): one query-term
+ * (`eqlIn` / `eqlNotIn`): one query-term
  * param per array element, template built per call from the array
  * length AND the domain's query cast. Empty arrays are rejected — an
  * OR-of-zero fragments has no well-defined lowering, and a silent
@@ -497,6 +505,96 @@ function membershipOperator(
   }
 }
 
+/**
+ * Normalise and guard a free-text search needle BEFORE it is encrypted
+ * (string needles only — envelope and non-string operands fall through
+ * to `coerceV3`, which owns their diagnostics):
+ *
+ *   1. SQL wildcards: leading/trailing `%` are stripped (an
+ *      `ilike`-shaped habit like `'%foo%'` still means "rows containing
+ *      foo" under token matching), while an interior `%` or any `_`
+ *      throws — the bloom tokenizer would treat them as ORDINARY
+ *      CHARACTERS and silently match nothing. Mirrors
+ *      stack-supabase's `likeNeedle`.
+ *   2. Short needles: a needle below the match index's tokenizer
+ *      length blooms to nothing and can match EVERY row; the shared
+ *      `matchNeedleError` guard (adapter-kit — same check as the
+ *      Drizzle and Supabase v3 surfaces) rejects it with the reason.
+ */
+function normalizeMatchNeedle(
+  ctx: ColumnContext,
+  value: unknown,
+  method: string,
+): unknown {
+  if (typeof value !== 'string') return value
+  const needle = value.replace(/^%+/, '').replace(/%+$/, '')
+  if (needle.includes('%') || value.includes('_')) {
+    throw operatorError(
+      ctx,
+      method,
+      `cipherstash ${method}: pattern ${JSON.stringify(value)} on column "${ctx.columnName ?? 'unknown'}" has wildcards fuzzy free-text matching cannot honor (an interior "%" or any "_"). Pass a literal search term.`,
+    )
+  }
+  const match = ctx.meta.indexes.match
+  if (match !== undefined) {
+    const reason = matchNeedleError(
+      needle,
+      // Narrowing assertion: `meta.indexes` is the widened
+      // `Record<string, unknown>` snapshot of the column's `build()`
+      // output; the `match` slot IS the match-index opts the shared
+      // guard reads (same source the Drizzle adapter passes through).
+      match as Parameters<typeof matchNeedleError>[1],
+    )
+    if (reason !== undefined) {
+      throw operatorError(
+        ctx,
+        method,
+        `Operator "${method}" cannot search column "${ctx.columnName ?? 'unknown'}": ${reason}`,
+      )
+    }
+  }
+  return needle
+}
+
+/**
+ * Fuzzy free-text token match on a `text_search`/`text_match` column,
+ * lowering to `eql_v3.contains` — NOT SQL pattern matching: matching is
+ * case-insensitive, order- and multiplicity-insensitive, and one-sided
+ * (may false-positive). The needle is normalised and guarded by
+ * {@link normalizeMatchNeedle} before encryption.
+ */
+function matchOperator(): SqlOperationDescriptor {
+  const method = 'eqlMatch'
+  return {
+    // See `fixedArityOperator` for the cast rationale.
+    self: {
+      traits: [
+        CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
+      ] as unknown as readonly CodecTrait[],
+    },
+    impl: (
+      self: Expression<ScopeField>,
+      needle: unknown,
+    ): Expression<PgBoolReturn> => {
+      const ctx = resolveContext(self, method)
+      gate(ctx, FREE_TEXT_GATE.capability, FREE_TEXT_GATE.label, method)
+      const cast = requireQueryCast(ctx, method)
+      const guarded = normalizeMatchNeedle(ctx, needle, method)
+      const argRef = asQueryTermParam(ctx, guarded, method, 'freeTextSearch')
+      return buildOperation({
+        method,
+        args: [ctx.selfAst, argRef],
+        returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+        lowering: {
+          targetFamily: 'sql',
+          strategy: 'function',
+          template: `eql_v3.contains({{self}}, {{arg0}}::${cast})`,
+        },
+      })
+    },
+  }
+}
+
 /**
  * Exact encrypted-JSONB containment on an `eql_v3_json` (`ste_vec`)
  * column: genuine jsonb `@>`, no false positives. `eql_v3_json` has no
@@ -507,13 +605,14 @@ function membershipOperator(
  * plus the cast disambiguate among the four `eql_v3_json @> ?` RHS
  * overloads ("operator is not unique", 42725).
  *
- * This mirrors the drizzle reference's `contains` under the v2 set's
- * `cipherstashJson*` naming convention. The reference exposes neither
- * a containedBy direction nor selector querying, so neither is
- * registered here.
+ * This mirrors the drizzle reference's `contains` under the v3 `eql*`
+ * naming vocabulary. Selector querying (comparing the value at a
+ * JSONPath via `eql_v3.jsonb_path_query_first` — the drizzle
+ * reference's `selectorOps`, #651) is tracked for prisma-next in #677;
+ * a containedBy direction is exposed by neither adapter.
  */
 function jsonContainsOperator(): SqlOperationDescriptor {
-  const method = 'cipherstashJsonContains'
+  const method = 'eqlJsonContains'
   return {
     // See `fixedArityOperator` for the cast rationale.
     self: {
@@ -562,24 +661,25 @@ function jsonContainsOperator(): SqlOperationDescriptor {
 /**
  * Cipherstash's v3 query-operations contributions. Wired into the v3
  * runtime descriptor (Task 7's `createCipherstashV3RuntimeDescriptor`)
- * — and ONLY that descriptor: the method names are shared with the v2
- * set, and the flat `OperationRegistry` rejects co-registration
- * (decision 1b; pinned in `test/v3/operator-gating-v3.test.ts`).
+ * — and ONLY that descriptor (decision 1b: a client is v2 or v3, never
+ * both; pinned in `test/v3/operator-gating-v3.test.ts`).
  *
  * Operator → trait → lowering:
  *
- *   - `cipherstashEq` / `cipherstashNe` / `cipherstashInArray` /
- *     `cipherstashNotInArray` (`cipherstash:equality`) →
+ *   - `eqlEq` / `eqlNeq` / `eqlIn` / `eqlNotIn`
+ *     (`cipherstash:equality`) →
  *     `eql_v3.eq` / `eql_v3.neq` / OR-of-eq
- *   - `cipherstashGt` / `Gte` / `Lt` / `Lte` / `Between` / `NotBetween`
- *     (`cipherstash:order-and-range`) → `eql_v3.gt`/`gte`/`lt`/`lte`,
- *     range as a self-parenthesised `(gte AND lte)` conjunction
- *   - `cipherstashIlike` / `cipherstashNotIlike`
- *     (`cipherstash:free-text-search`) → `eql_v3.contains` — a
- *     bloom-filter TOKEN MATCH (order/multiplicity-insensitive,
- *     one-sided: may false-positive), NOT SQL ILIKE; the v2 method
- *     names are kept for surface continuity.
- *   - `cipherstashJsonContains` (`cipherstash:searchable-json`) →
+ *   - `eqlGt` / `eqlGte` / `eqlLt` / `eqlLte` / `eqlBetween` /
+ *     `eqlNotBetween` (`cipherstash:order-and-range`) →
+ *     `eql_v3.gt`/`gte`/`lt`/`lte`, range as a self-parenthesised
+ *     `(gte AND lte)` conjunction
+ *   - `eqlMatch` (`cipherstash:free-text-search`) → `eql_v3.contains`
+ *     — a bloom-filter TOKEN MATCH (order/multiplicity-insensitive,
+ *     one-sided: may false-positive), NOT SQL pattern matching. Guarded
+ *     up front: needles the column's match index cannot answer are
+ *     rejected (`matchNeedleError`), and SQL wildcards are normalised
+ *     away or rejected (see {@link matchOperator}).
+ *   - `eqlJsonContains` (`cipherstash:searchable-json`) →
  *     exact jsonb containment via `OPERATOR(public.@>)`.
  *
  * Every operand renders as `$n::eql_v3.query_<domain>` (irregularly
@@ -588,50 +688,50 @@ function jsonContainsOperator(): SqlOperationDescriptor {
  */
 export function cipherstashV3QueryOperations(): SqlOperationDescriptors {
   return {
-    cipherstashEq: fixedArityOperator(
-      'cipherstashEq',
+    eqlEq: fixedArityOperator(
+      'eqlEq',
       CIPHERSTASH_TRAIT_EQUALITY,
       1,
       EQUALITY_GATE,
       'equality',
       (cast) => `eql_v3.eq({{self}}, {{arg0}}::${cast})`,
     ),
-    cipherstashNe: fixedArityOperator(
-      'cipherstashNe',
+    eqlNeq: fixedArityOperator(
+      'eqlNeq',
       CIPHERSTASH_TRAIT_EQUALITY,
       1,
       EQUALITY_GATE,
       'equality',
       (cast) => `eql_v3.neq({{self}}, {{arg0}}::${cast})`,
     ),
-    cipherstashInArray: membershipOperator('cipherstashInArray', false),
-    cipherstashNotInArray: membershipOperator('cipherstashNotInArray', true),
-    cipherstashGt: fixedArityOperator(
-      'cipherstashGt',
+    eqlIn: membershipOperator('eqlIn', false),
+    eqlNotIn: membershipOperator('eqlNotIn', true),
+    eqlGt: fixedArityOperator(
+      'eqlGt',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       1,
       ORDERING_GATE,
       'orderAndRange',
       (cast) => `eql_v3.gt({{self}}, {{arg0}}::${cast})`,
     ),
-    cipherstashGte: fixedArityOperator(
-      'cipherstashGte',
+    eqlGte: fixedArityOperator(
+      'eqlGte',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       1,
       ORDERING_GATE,
       'orderAndRange',
       (cast) => `eql_v3.gte({{self}}, {{arg0}}::${cast})`,
     ),
-    cipherstashLt: fixedArityOperator(
-      'cipherstashLt',
+    eqlLt: fixedArityOperator(
+      'eqlLt',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       1,
       ORDERING_GATE,
       'orderAndRange',
       (cast) => `eql_v3.lt({{self}}, {{arg0}}::${cast})`,
     ),
-    cipherstashLte: fixedArityOperator(
-      'cipherstashLte',
+    eqlLte: fixedArityOperator(
+      'eqlLte',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       1,
       ORDERING_GATE,
@@ -645,8 +745,8 @@ export function cipherstashV3QueryOperations(): SqlOperationDescriptors {
     // composition, …) parses as `(NOT gte) AND lte` — rows BELOW the
     // lower bound instead of the range complement. Parenthesising here
     // makes every composition safe instead of relying on each caller.
-    cipherstashBetween: fixedArityOperator(
-      'cipherstashBetween',
+    eqlBetween: fixedArityOperator(
+      'eqlBetween',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       2,
       ORDERING_GATE,
@@ -654,8 +754,8 @@ export function cipherstashV3QueryOperations(): SqlOperationDescriptors {
       (cast) =>
         `(eql_v3.gte({{self}}, {{arg0}}::${cast}) AND eql_v3.lte({{self}}, {{arg1}}::${cast}))`,
     ),
-    cipherstashNotBetween: fixedArityOperator(
-      'cipherstashNotBetween',
+    eqlNotBetween: fixedArityOperator(
+      'eqlNotBetween',
       CIPHERSTASH_TRAIT_ORDER_AND_RANGE,
       2,
       ORDERING_GATE,
@@ -663,26 +763,14 @@ export function cipherstashV3QueryOperations(): SqlOperationDescriptors {
       (cast) =>
         `NOT (eql_v3.gte({{self}}, {{arg0}}::${cast}) AND eql_v3.lte({{self}}, {{arg1}}::${cast}))`,
     ),
-    // ilike/notIlike lower to eql_v3.contains — bloom-filter token
-    // matching, NOT SQL ILIKE (may false-positive; carry this caveat
-    // into user docs).
-    cipherstashIlike: fixedArityOperator(
-      'cipherstashIlike',
-      CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
-      1,
-      FREE_TEXT_GATE,
-      'freeTextSearch',
-      (cast) => `eql_v3.contains({{self}}, {{arg0}}::${cast})`,
-    ),
-    cipherstashNotIlike: fixedArityOperator(
-      'cipherstashNotIlike',
-      CIPHERSTASH_TRAIT_FREE_TEXT_SEARCH,
-      1,
-      FREE_TEXT_GATE,
-      'freeTextSearch',
-      (cast) => `NOT eql_v3.contains({{self}}, {{arg0}}::${cast})`,
-    ),
-    cipherstashJsonContains: jsonContainsOperator(),
+    eqlMatch: matchOperator(),
+    // NO negated match: `eql_v3.contains` is a bloom-filter test that
+    // may FALSE-POSITIVE, so its negation FALSE-NEGATIVES — it would
+    // silently drop rows that genuinely don't match. A trustworthy
+    // negative free-text search needs a decrypt-and-post-filter path;
+    // until one exists the operator must not be offered (PR #655
+    // review; same removal as the Drizzle/Supabase v3 surfaces).
+    eqlJsonContains: jsonContainsOperator(),
   }
 }
 
@@ -727,22 +815,20 @@ function ordTermExpression(
  * A free-standing helper, not a registered operator — same rationale
  * as the v2 `cipherstashAsc`: sort returns an `OrderByItem`, not the
  * boolean predicate the registry's where-binding pipeline expects. The
- * `V3` suffix keeps the export distinct from the v2 helper (unlike
- * registry method names, free-standing exports share one barrel
+ * `eql` prefix keeps the export distinct from the v2 helper AND names
+ * the vocabulary it belongs to (free-standing exports share one barrel
  * namespace). Unlike v2 (bare-column sort over `eql_v2_encrypted`'s
  * native operator family), v3 domains have no cross-row comparison
  * operators — sorting MUST extract the order term. Synchronous: no
  * operand, so no query term is minted.
  */
-export function cipherstashV3Asc(col: Expression<ScopeField>): OrderByItem {
-  return OrderByItem.asc(ordTermExpression(col, 'cipherstashV3Asc').buildAst())
+export function eqlAsc(col: Expression<ScopeField>): OrderByItem {
+  return OrderByItem.asc(ordTermExpression(col, 'eqlAsc').buildAst())
 }
 
 /**
- * DESC sort over an order-capable v3 column. See {@link cipherstashV3Asc}.
+ * DESC sort over an order-capable v3 column. See {@link eqlAsc}.
  */
-export function cipherstashV3Desc(col: Expression<ScopeField>): OrderByItem {
-  return OrderByItem.desc(
-    ordTermExpression(col, 'cipherstashV3Desc').buildAst(),
-  )
+export function eqlDesc(col: Expression<ScopeField>): OrderByItem {
+  return OrderByItem.desc(ordTermExpression(col, 'eqlDesc').buildAst())
 }
diff --git a/packages/prisma-next/src/v3/runtime-v3.ts b/packages/prisma-next/src/v3/runtime-v3.ts
index e90b35a4..ec16933e 100644
--- a/packages/prisma-next/src/v3/runtime-v3.ts
+++ b/packages/prisma-next/src/v3/runtime-v3.ts
@@ -19,12 +19,10 @@
  * rejects a v3 contract at startup with
  * `RUNTIME.MISSING_EXTENSION_PACK`. The descriptor's VERSION carries
  * v3's own identity (`CIPHERSTASH_V3_EXTENSION_VERSION`), and decision
- * 1b's separation holds regardless: the registered method names
- * (`cipherstashEq`, …) are identical to the v2 set, so the v2 and v3
- * descriptors must NEVER be co-registered in one client — the flat,
- * method-name-keyed `OperationRegistry` throws on the shared names
- * (pinned in `test/v3/operator-gating-v3.test.ts`). A client is v2 or
- * v3, never both.
+ * 1b's separation holds regardless: the v3 method names (`eqlEq`, …)
+ * are disjoint from the v2 set, but the v2 and v3 descriptors must
+ * still NEVER be co-registered in one client — a client is v2 or v3,
+ * never both (pinned in `test/v3/operator-gating-v3.test.ts`).
  *
  * The v3 bulk-encrypt middleware ships separately
  * (`bulkEncryptMiddlewareV3(sdk)`) because
diff --git a/packages/prisma-next/test/column-types.test.ts b/packages/prisma-next/test/column-types.test.ts
index 272381c0..9cda0696 100644
--- a/packages/prisma-next/test/column-types.test.ts
+++ b/packages/prisma-next/test/column-types.test.ts
@@ -79,6 +79,40 @@ describe('v3 TS factories', () => {
     })
   })
 
+  it('returns a FRESH descriptor per invocation — mutating one cannot affect the next', () => {
+    // Descriptors flow into caller-owned contract structures; a shared
+    // instance would make one caller's mutation alter every later
+    // contract (call-order-dependent output). `v3Authored` shallow-copies
+    // the capabilities block per call, pinned here.
+    const first = columnTypes.encryptedTextSearch()
+    const second = columnTypes.encryptedTextSearch()
+    expect(second).not.toBe(first)
+    expect(second.typeParams.capabilities).not.toBe(
+      first.typeParams.capabilities,
+    )
+
+    // Sabotage the first descriptor (test-only mutability cast — the
+    // descriptor type is readonly by design).
+    const mutable = first.typeParams.capabilities as {
+      equality: boolean
+      freeTextSearch: boolean
+    }
+    mutable.equality = false
+    mutable.freeTextSearch = false
+
+    // Neither the already-returned sibling nor a fresh call sees it.
+    expect(second.typeParams.capabilities).toEqual({
+      equality: true,
+      orderAndRange: true,
+      freeTextSearch: true,
+    })
+    expect(columnTypes.encryptedTextSearch().typeParams.capabilities).toEqual({
+      equality: true,
+      orderAndRange: true,
+      freeTextSearch: true,
+    })
+  })
+
   it('exposes no *OrdOre factories and no v3 encryptedString', () => {
     const exported = columnTypes as Record<string, unknown>
     expect(exported['encryptedBigIntOrdOre']).toBeUndefined()
diff --git a/packages/prisma-next/test/operation-types.types.test-d.ts b/packages/prisma-next/test/operation-types.types.test-d.ts
index 334c39d3..22fdc87d 100644
--- a/packages/prisma-next/test/operation-types.types.test-d.ts
+++ b/packages/prisma-next/test/operation-types.types.test-d.ts
@@ -7,24 +7,30 @@
  * matching behaviour can be exercised against a synthetic
  * `CodecTypes` table without pulling in the full ORM model accessor.
  *
- * The tests pin two surface contracts:
+ * The tests pin three surface contracts:
  *
- *   1. **Codec-id dispatch (positive/negative)** for the legacy and
- *      single-codec entries (`cipherstashEq`, `cipherstashIlike`,
- *      `cipherstashNotIlike`, `cipherstashJsonbPathExists`):
+ *   1. **Codec-id dispatch (positive/negative)** for the legacy
+ *      single-codec entries (`cipherstashEq`, `cipherstashIlike`):
  *      the operator must surface on its target codec id and on no
  *      other.
  *
  *   2. **Trait dispatch (positive/negative)** for the multi-codec
  *      entries (`cipherstashNe`, `cipherstashInArray`,
- *      `cipherstashNotInArray`, `cipherstashGt`, `cipherstashGte`,
- *      `cipherstashLt`, `cipherstashLte`, `cipherstashBetween`,
- *      `cipherstashNotBetween`): the operator must surface on every
- *      cipherstash codec whose trait set carries the gating trait
+ *      `cipherstashNotInArray`, `cipherstashNotIlike`,
+ *      `cipherstashGt`, `cipherstashGte`, `cipherstashLt`,
+ *      `cipherstashLte`, `cipherstashBetween`, `cipherstashNotBetween`,
+ *      `cipherstashJsonbPathExists`): the operator must surface on
+ *      every cipherstash codec whose trait set carries the gating trait
  *      and on no codec without it (notably `pg/text@1`, which is the
  *      regression-pinning negative case for the wrong-SQL `eq`
  *      footgun).
  *
+ *   3. **Generation split** for the v3 `eql*` entries (against the
+ *      REAL `CodecTypes` table): every `eql*` operator dispatches on a
+ *      `cipherstash:v3-*` marker only v3 entries carry, and no v2
+ *      `cipherstash*` operator surfaces on a v3 column — both
+ *      directions of the disjoint-name-set correspondence.
+ *
  * AGENTS.md permits `@ts-expect-error` exclusively in negative
  * type-test files; this is one of them.
  */
@@ -135,7 +141,7 @@ type _ilike_string_pos = Expect<M<'cipherstashIlike', 'cipherstash/string@1'>>
 // @ts-expect-error cipherstashIlike must not surface on cipherstash/double@1.
 type _ilike_double_neg = Expect<M<'cipherstashIlike', 'cipherstash/double@1'>>
 
-// -- cipherstashNotIlike (string only — single-codec dispatch) ---------------
+// -- cipherstashNotIlike (free-text-search trait dispatch) --------------------
 
 type _notilike_string_pos = Expect<
   M<'cipherstashNotIlike', 'cipherstash/string@1'>
@@ -217,7 +223,7 @@ type _between_boolean_neg = Expect<
 // @ts-expect-error cipherstashNotBetween must not surface on pg/text@1.
 type _notbetween_text_neg = Expect<M<'cipherstashNotBetween', 'pg/text@1'>>
 
-// -- cipherstashJsonbPathExists (json only — single-codec dispatch) ---------
+// -- cipherstashJsonbPathExists (searchable-json trait dispatch) --------------
 
 type _jpe_json_pos = Expect<
   M<'cipherstashJsonbPathExists', 'cipherstash/json@1'>
@@ -234,14 +240,19 @@ type _jpe_text_neg = Expect<M<'cipherstashJsonbPathExists', 'pg/text@1'>>
 // The v3 assertions run against the real `CodecTypes` export (which
 // carries the 40 v3 entries plus the `cipherstash:v3-*` type-level
 // markers) rather than the synthetic table above, so drift in the real
-// table breaks this file. Pins the generation-split contracts:
+// table breaks this file. Pins the generation-split contracts (the v2
+// `cipherstash*` and v3 `eql*` method-name sets are disjoint — PR #655
+// review):
 //
-//   - `cipherstashEq` / `cipherstashIlike` (codec-id-pinned in v2)
-//     surface on v3 columns via the marker-trait fall-through.
-//   - `cipherstashJsonContains` is v3-json-only; the v2-only
-//     `cipherstashJsonbPathExists` must NOT surface on v3 json.
-//   - Storage-only v3 domains (boolean, bare `eql_v3_text`) surface
-//     NO cipherstash operators at all.
+//   - every `eql*` operator surfaces exactly on the v3 columns whose
+//     marker tier carries its capability, and on NO v2 codec;
+//   - no v2 `cipherstash*` operator surfaces on any v3 column — v3
+//     entries carry only `cipherstash:v3-*` markers, never the shared
+//     v2 trait strings or the legacy codec-id pin;
+//   - storage-only v3 domains (boolean, bare `eql_v3_text`) surface
+//     NO operators at all;
+//   - the retired names (`cipherstashJsonContains`, and any negated
+//     match) are gone from the operation table entirely.
 
 type RealOps = QueryOperationTypes<RealCodecTypes>
 type M3<N extends keyof RealOps, C extends string> = OpMatchesField<
@@ -250,49 +261,93 @@ type M3<N extends keyof RealOps, C extends string> = OpMatchesField<
   RealCodecTypes
 >
 
+// Retired names must not re-enter the table: `cipherstashJsonContains`
+// was renamed to `eqlJsonContains`, and a negated match must not exist
+// under either vocabulary (bloom negation false-negatives).
+type RetiredNames = Extract<
+  keyof RealOps,
+  'cipherstashJsonContains' | 'eqlNotMatch'
+>
+type _RetiredNamesAbsent = [RetiredNames] extends [never]
+  ? true
+  : ['operation table resurrects retired names', RetiredNames]
+const _retiredNamesAbsent: _RetiredNamesAbsent = true
+void _retiredNamesAbsent
+
+// v3 positives: each marker tier surfaces its operator family.
 type _v3_eq_search_pos = Expect<
-  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+  M3<'eqlEq', 'cipherstash/eql-v3/eql_v3_text_search@1'>
 >
 type _v3_eq_bigint_eq_pos = Expect<
-  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_bigint_eq@1'>
+  M3<'eqlEq', 'cipherstash/eql-v3/eql_v3_bigint_eq@1'>
 >
-type _v3_eq_boolean_neg = Expect<
-  // @ts-expect-error cipherstashEq must not surface on storage-only eql_v3_boolean.
-  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_boolean@1'>
+type _v3_in_texteq_pos = Expect<
+  M3<'eqlIn', 'cipherstash/eql-v3/eql_v3_text_eq@1'>
 >
-type _v3_eq_text_storage_neg = Expect<
-  // @ts-expect-error cipherstashEq must not surface on storage-only eql_v3_text.
-  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_text@1'>
+type _v3_match_search_pos = Expect<
+  M3<'eqlMatch', 'cipherstash/eql-v3/eql_v3_text_search@1'>
 >
-type _v3_ilike_search_pos = Expect<
-  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+type _v3_match_textmatch_pos = Expect<
+  M3<'eqlMatch', 'cipherstash/eql-v3/eql_v3_text_match@1'>
 >
-type _v3_ilike_match_pos = Expect<
-  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_match@1'>
+type _v3_gt_ord_pos = Expect<
+  M3<'eqlGt', 'cipherstash/eql-v3/eql_v3_double_ord@1'>
 >
-type _v3_ilike_eq_neg = Expect<
-  // @ts-expect-error cipherstashIlike must not surface on eql_v3_text_eq (no free-text index).
-  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_eq@1'>
+type _v3_jsoncontains_json_pos = Expect<
+  M3<'eqlJsonContains', 'cipherstash/eql-v3/eql_v3_json@1'>
 >
-type _v3_gt_ord_pos = Expect<
-  M3<'cipherstashGt', 'cipherstash/eql-v3/eql_v3_double_ord@1'>
+
+// v3 negatives: capability tiers gate visibility.
+type _v3_eq_boolean_neg = Expect<
+  // @ts-expect-error eqlEq must not surface on storage-only eql_v3_boolean.
+  M3<'eqlEq', 'cipherstash/eql-v3/eql_v3_boolean@1'>
+>
+type _v3_eq_text_storage_neg = Expect<
+  // @ts-expect-error eqlEq must not surface on storage-only eql_v3_text.
+  M3<'eqlEq', 'cipherstash/eql-v3/eql_v3_text@1'>
+>
+type _v3_match_texteq_neg = Expect<
+  // @ts-expect-error eqlMatch must not surface on eql_v3_text_eq (no free-text index).
+  M3<'eqlMatch', 'cipherstash/eql-v3/eql_v3_text_eq@1'>
 >
 type _v3_gt_eqonly_neg = Expect<
-  // @ts-expect-error cipherstashGt must not surface on eql_v3_double_eq (no order/range).
-  M3<'cipherstashGt', 'cipherstash/eql-v3/eql_v3_double_eq@1'>
+  // @ts-expect-error eqlGt must not surface on eql_v3_double_eq (no order/range).
+  M3<'eqlGt', 'cipherstash/eql-v3/eql_v3_double_eq@1'>
 >
-type _v3_ina_boolean_neg = Expect<
-  // @ts-expect-error cipherstashInArray must not surface on storage-only eql_v3_boolean.
-  M3<'cipherstashInArray', 'cipherstash/eql-v3/eql_v3_boolean@1'>
+type _v3_in_boolean_neg = Expect<
+  // @ts-expect-error eqlIn must not surface on storage-only eql_v3_boolean.
+  M3<'eqlIn', 'cipherstash/eql-v3/eql_v3_boolean@1'>
 >
-type _v3_jsoncontains_json_pos = Expect<
-  M3<'cipherstashJsonContains', 'cipherstash/eql-v3/eql_v3_json@1'>
+
+// Generation split, v3→v2 direction: `eql*` never surfaces on a v2 codec.
+type _v3_eq_v2string_neg = Expect<
+  // @ts-expect-error eqlEq must not surface on the v2 string codec.
+  M3<'eqlEq', 'cipherstash/string@1'>
+>
+type _v3_match_v2string_neg = Expect<
+  // @ts-expect-error eqlMatch must not surface on the v2 string codec.
+  M3<'eqlMatch', 'cipherstash/string@1'>
 >
 type _v3_jsoncontains_v2json_neg = Expect<
-  // @ts-expect-error cipherstashJsonContains must not surface on the v2 json codec.
-  M3<'cipherstashJsonContains', 'cipherstash/json@1'>
+  // @ts-expect-error eqlJsonContains must not surface on the v2 json codec.
+  M3<'eqlJsonContains', 'cipherstash/json@1'>
 >
-type _v3_jpe_v3json_neg = Expect<
+
+// Generation split, v2→v3 direction: `cipherstash*` never surfaces on a
+// v3 column (v3 entries carry no shared v2 trait and no legacy codec id).
+type _v2_eq_v3search_neg = Expect<
+  // @ts-expect-error v2 cipherstashEq must not surface on eql_v3_text_search.
+  M3<'cipherstashEq', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+>
+type _v2_ilike_v3search_neg = Expect<
+  // @ts-expect-error v2 cipherstashIlike must not surface on eql_v3_text_search.
+  M3<'cipherstashIlike', 'cipherstash/eql-v3/eql_v3_text_search@1'>
+>
+type _v2_gt_v3ord_neg = Expect<
+  // @ts-expect-error v2 cipherstashGt must not surface on eql_v3_double_ord.
+  M3<'cipherstashGt', 'cipherstash/eql-v3/eql_v3_double_ord@1'>
+>
+type _v2_jpe_v3json_neg = Expect<
   // @ts-expect-error v2-only cipherstashJsonbPathExists must not surface on eql_v3_json.
   M3<'cipherstashJsonbPathExists', 'cipherstash/eql-v3/eql_v3_json@1'>
 >
@@ -302,17 +357,23 @@ type _v3_jpe_v3json_neg = Expect<
 export type _Anchors = [
   _v3_eq_search_pos,
   _v3_eq_bigint_eq_pos,
+  _v3_in_texteq_pos,
+  _v3_match_search_pos,
+  _v3_match_textmatch_pos,
+  _v3_gt_ord_pos,
+  _v3_jsoncontains_json_pos,
   _v3_eq_boolean_neg,
   _v3_eq_text_storage_neg,
-  _v3_ilike_search_pos,
-  _v3_ilike_match_pos,
-  _v3_ilike_eq_neg,
-  _v3_gt_ord_pos,
+  _v3_match_texteq_neg,
   _v3_gt_eqonly_neg,
-  _v3_ina_boolean_neg,
-  _v3_jsoncontains_json_pos,
+  _v3_in_boolean_neg,
+  _v3_eq_v2string_neg,
+  _v3_match_v2string_neg,
   _v3_jsoncontains_v2json_neg,
-  _v3_jpe_v3json_neg,
+  _v2_eq_v3search_neg,
+  _v2_ilike_v3search_neg,
+  _v2_gt_v3ord_neg,
+  _v2_jpe_v3json_neg,
   _eq_string_pos,
   _eq_double_neg,
   _eq_text_neg,
diff --git a/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
index bb4519d7..11a73320 100644
--- a/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
+++ b/packages/prisma-next/test/v3/bulk-encrypt-v3.test.ts
@@ -205,6 +205,31 @@ describe('bulkEncryptMiddlewareV3', () => {
     })
   })
 
+  describe('routing key write-once contract', () => {
+    it('rejects one envelope instance reused across two different columns', async () => {
+      // Same programming-error pin as the v2 suite
+      // (`../bulk-encrypt-middleware.test.ts`), through the v3 path:
+      // `stampRoutingKeysFromAst` stamps the first column, then
+      // `setHandleRoutingKey` throws on the conflicting reassignment so
+      // the envelope cannot silently retain a stale binding and route
+      // to the wrong bulk-encrypt batch.
+      const sdk = makeV3Sdk()
+      const middleware = bulkEncryptMiddlewareV3(sdk)
+      const envelope = EncryptedString.from('alice@example.com')
+      const plan = buildInsertPlan(
+        'user',
+        [{ email: envelope, username: envelope }],
+        V3_TEXT_SEARCH,
+      )
+      const params = createSqlParamRefMutator(plan)
+
+      await expect(
+        middleware.beforeExecute?.(plan, createCtx(), params),
+      ).rejects.toThrow(/routing-key (table|column) conflict/)
+      expect(sdk.bulkEncryptCalls).toEqual([])
+    })
+  })
+
   describe('jurisdiction is the v3 codec-id set only', () => {
     it('ignores v2-codec params', async () => {
       const sdk = makeV3Sdk()
@@ -294,13 +319,20 @@ describe('bulkEncryptMiddlewareV3', () => {
       const controller = new AbortController()
       controller.abort()
 
+      // The rejection is the cipherstash-tagged `RUNTIME.ABORTED`
+      // envelope (`checkCipherstashAborted(ctx.signal, 'bulk-encrypt')`
+      // in `src/execution/abort.ts`), not just any error.
       await expect(
         middleware.beforeExecute?.(
           plan,
           createCtx({ signal: controller.signal }),
           params,
         ),
-      ).rejects.toThrow()
+      ).rejects.toMatchObject({
+        code: 'RUNTIME.ABORTED',
+        message: 'Operation aborted during bulk-encrypt',
+        details: { phase: 'bulk-encrypt' },
+      })
       expect(sdk.bulkEncryptCalls).toEqual([])
     })
   })
@@ -464,13 +496,13 @@ describe('bulkEncryptMiddlewareV3', () => {
       expect(sdk.bulkEncryptCalls).toEqual([])
     })
 
-    it('END-TO-END: a real cipherstashEq lowering feeds the seam and the param lands as query-term JSONB', async () => {
+    it('END-TO-END: a real eqlEq lowering feeds the seam and the param lands as query-term JSONB', async () => {
       const term = { i: { t: TABLE, c: 'score' }, ob: ['deadbeef'] }
       const sdk = makeCounterSdk({ encryptImpl: () => [term] })
       const middleware = bulkEncryptMiddlewareV3(sdk)
 
       const predicate = callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         42,
       )
diff --git a/packages/prisma-next/test/v3/codec-types-v3.test-d.ts b/packages/prisma-next/test/v3/codec-types-v3.test-d.ts
index 04fcfde2..8fec2f1d 100644
--- a/packages/prisma-next/test/v3/codec-types-v3.test-d.ts
+++ b/packages/prisma-next/test/v3/codec-types-v3.test-d.ts
@@ -13,8 +13,12 @@
  *      pinned union — the table and the catalog can only drift
  *      together, and `constants-v3.ts` already locks the catalog.
  *   3. Spot-pins for each capability tier: output envelope class and
- *      the exact type-level trait union (shared strings + `v3-*`
- *      markers) for a representative domain per tier.
+ *      the exact type-level trait union for a representative domain
+ *      per tier. v3 entries carry ONLY the `cipherstash:v3-*` markers —
+ *      the v2 and v3 method names are disjoint (`cipherstash*` vs
+ *      `eql*`, PR #655 review), so the shared v2 trait strings must
+ *      never appear on a v3 entry (they would surface v2 methods a v3
+ *      runtime cannot dispatch).
  *
  * AGENTS.md permits `@ts-expect-error` exclusively in negative
  * type-test files; this is one of them.
@@ -63,22 +67,20 @@ describe('v3 CodecTypes entries', () => {
     >().toEqualTypeOf<never>()
   })
 
-  it('_eq domains carry equality + the v3-equality marker', () => {
+  it('_eq domains carry only the v3-equality marker', () => {
     expectTypeOf<
       CodecTypes['cipherstash/eql-v3/eql_v3_bigint_eq@1']['traits']
-    >().toEqualTypeOf<'cipherstash:equality' | 'cipherstash:v3-equality'>()
+    >().toEqualTypeOf<'cipherstash:v3-equality'>()
     expectTypeOf<
       CodecTypes['cipherstash/eql-v3/eql_v3_bigint_eq@1']['output']
     >().toEqualTypeOf<EncryptedBigInt>()
   })
 
-  it('_ord domains add order-and-range', () => {
+  it('_ord domains add the v3-order-and-range marker', () => {
     expectTypeOf<
       CodecTypes['cipherstash/eql-v3/eql_v3_double_ord@1']['traits']
     >().toEqualTypeOf<
-      | 'cipherstash:equality'
-      | 'cipherstash:v3-equality'
-      | 'cipherstash:order-and-range'
+      'cipherstash:v3-equality' | 'cipherstash:v3-order-and-range'
     >()
     // v3 `number`-castAs domains decode to EncryptedNumber, NOT the v2
     // EncryptedDouble.
@@ -87,22 +89,18 @@ describe('v3 CodecTypes entries', () => {
     >().toEqualTypeOf<EncryptedNumber>()
   })
 
-  it('text_match carries only the free-text pair', () => {
+  it('text_match carries only the v3-free-text-search marker', () => {
     expectTypeOf<
       CodecTypes['cipherstash/eql-v3/eql_v3_text_match@1']['traits']
-    >().toEqualTypeOf<
-      'cipherstash:free-text-search' | 'cipherstash:v3-free-text-search'
-    >()
+    >().toEqualTypeOf<'cipherstash:v3-free-text-search'>()
   })
 
-  it('text_search carries the full scalar tier', () => {
+  it('text_search carries the full scalar marker tier', () => {
     expectTypeOf<
       CodecTypes['cipherstash/eql-v3/eql_v3_text_search@1']['traits']
     >().toEqualTypeOf<
-      | 'cipherstash:equality'
       | 'cipherstash:v3-equality'
-      | 'cipherstash:order-and-range'
-      | 'cipherstash:free-text-search'
+      | 'cipherstash:v3-order-and-range'
       | 'cipherstash:v3-free-text-search'
     >()
     expectTypeOf<
@@ -118,4 +116,16 @@ describe('v3 CodecTypes entries', () => {
       CodecTypes['cipherstash/eql-v3/eql_v3_json@1']['output']
     >().toEqualTypeOf<EncryptedJson>()
   })
+
+  it('no v3 entry leaks a shared v2 trait string (the v2 method set must not surface on v3 columns)', () => {
+    type V3Traits = CodecTypes[V3ShapedKeys]['traits']
+    type LeakedV2Traits = Extract<
+      V3Traits,
+      | 'cipherstash:equality'
+      | 'cipherstash:order-and-range'
+      | 'cipherstash:free-text-search'
+      | 'cipherstash:searchable-json'
+    >
+    expectTypeOf<LeakedV2Traits>().toEqualTypeOf<never>()
+  })
 })
diff --git a/packages/prisma-next/test/v3/operator-gating-v3.test.ts b/packages/prisma-next/test/v3/operator-gating-v3.test.ts
index 97dcaf57..89b6637b 100644
--- a/packages/prisma-next/test/v3/operator-gating-v3.test.ts
+++ b/packages/prisma-next/test/v3/operator-gating-v3.test.ts
@@ -9,41 +9,40 @@
  * (or through a custom builder) must still be stopped when the domain
  * cannot answer the operator.
  *
- * Also pins decision 1b's registration constraint: the v3 descriptor
- * stands alone (a v3-only adapter builds cleanly), and co-registering
- * the v2 and v3 descriptors throws — the framework's flat
- * `OperationRegistry` rejects two descriptors sharing the
- * `cipherstashEq` method name. v2 and v3 are separate entry points,
- * never composed into one client.
+ * Also pins decision 1b's registration posture: the v3 descriptor
+ * stands alone (a v3-only adapter builds cleanly), and the v2
+ * `cipherstash*` and v3 `eql*` method-name sets are DISJOINT — the two
+ * surfaces share no registry key, so a client is v2 or v3 purely by
+ * which descriptor it was constructed with, never by registry
+ * collision. v2 and v3 remain separate entry points, never composed
+ * into one client.
  */
 
 import { describe, expect, it } from 'vitest'
-import { createCipherstashRuntimeDescriptor } from '../../src/exports/runtime'
+import { cipherstashQueryOperations } from '../../src/execution/operators'
 import {
-  cipherstashV3Asc,
   cipherstashV3QueryOperations,
   EncryptionOperatorError,
+  eqlAsc,
 } from '../../src/v3/operators-v3'
 import {
   assembleV3ExecutionContext,
   BOOLEAN_CODEC_ID,
   callOperator,
   columnAccessorV3,
-  emptySdk,
   getOperator,
   JSON_CODEC_ID,
   makeV3Adapter,
   TABLE,
   TEXT_EQ_CODEC_ID,
   TEXT_STORAGE_CODEC_ID,
-  v3RuntimeDescriptor,
 } from './operator-lowering-v3.helpers'
 
 describe('v3 operator capability gating', () => {
-  it('equality requires the equality capability — storage-only eql_v3_text rejects cipherstashEq', () => {
+  it('equality requires the equality capability — storage-only eql_v3_text rejects eqlEq', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'note', TEXT_STORAGE_CODEC_ID),
         'x',
       ),
@@ -53,60 +52,60 @@ describe('v3 operator capability gating', () => {
   it('names the column, domain, operator, and missing capability in the diagnostic', () => {
     try {
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'note', TEXT_STORAGE_CODEC_ID),
         'x',
       )
-      expect.unreachable('cipherstashEq on a storage-only column must throw')
+      expect.unreachable('eqlEq on a storage-only column must throw')
     } catch (error) {
       expect(error).toBeInstanceOf(EncryptionOperatorError)
       const operatorError = error as EncryptionOperatorError
-      expect(operatorError.message).toContain('cipherstashEq')
+      expect(operatorError.message).toContain('eqlEq')
       expect(operatorError.message).toContain('equality')
       expect(operatorError.message).toContain('"note"')
       expect(operatorError.message).toContain('public.eql_v3_text')
       expect(operatorError.context).toEqual({
         columnName: 'note',
         tableName: TABLE,
-        operator: 'cipherstashEq',
+        operator: 'eqlEq',
       })
     }
   })
 
-  it('comparison requires order/range — text_eq rejects cipherstashGt', () => {
+  it('comparison requires order/range — text_eq rejects eqlGt', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashGt'),
+        getOperator('eqlGt'),
         columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
         'x',
       ),
     ).toThrow(/order\/range/)
   })
 
-  it('free-text requires the match index — text_eq rejects cipherstashIlike', () => {
+  it('free-text requires the match index — text_eq rejects eqlMatch', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashIlike'),
+        getOperator('eqlMatch'),
         columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
         'x',
       ),
     ).toThrow(/free-text/)
   })
 
-  it('JSON containment requires searchableJson — text_eq rejects cipherstashJsonContains', () => {
+  it('JSON containment requires searchableJson — text_eq rejects eqlJsonContains', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashJsonContains'),
+        getOperator('eqlJsonContains'),
         columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
         { role: 'admin' },
       ),
     ).toThrow(/JSON containment/)
   })
 
-  it('eql_v3_json is searchableJson-only — rejects cipherstashEq', () => {
+  it('eql_v3_json is searchableJson-only — rejects eqlEq', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
         { role: 'admin' },
       ),
@@ -115,11 +114,11 @@ describe('v3 operator capability gating', () => {
 
   it('storage-only eql_v3_boolean rejects every search operator', () => {
     for (const method of [
-      'cipherstashEq',
-      'cipherstashNe',
-      'cipherstashGt',
-      'cipherstashIlike',
-      'cipherstashJsonContains',
+      'eqlEq',
+      'eqlNeq',
+      'eqlGt',
+      'eqlMatch',
+      'eqlJsonContains',
     ]) {
       expect(() =>
         callOperator(
@@ -131,16 +130,16 @@ describe('v3 operator capability gating', () => {
     }
   })
 
-  it('ordering helpers gate on order/range — text_eq rejects cipherstashV3Asc', () => {
+  it('ordering helpers gate on order/range — text_eq rejects eqlAsc', () => {
     expect(() =>
-      cipherstashV3Asc(columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID)),
+      eqlAsc(columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID)),
     ).toThrow(/order\/range/)
   })
 
   it('rejects a non-v3 codec id (v2 columns are the wrong entry point)', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'email', 'cipherstash/string@1'),
         'x',
       ),
@@ -150,7 +149,7 @@ describe('v3 operator capability gating', () => {
   it('rejects a self expression with no codec binding', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         {
           buildAst: () => {
             throw new Error('unreachable')
@@ -167,7 +166,7 @@ describe('v3 descriptor registration (decision 1b)', () => {
     expect(() => makeV3Adapter()).not.toThrow()
     // The execution context is what assembles the flat operation
     // registry from `queryOperations()` — a v3-only stack registers the
-    // full `cipherstash*` method set without collision.
+    // full `eql*` method set without collision.
     const registered = Object.keys(
       assembleV3ExecutionContext().queryOperations.entries(),
     )
@@ -176,18 +175,25 @@ describe('v3 descriptor registration (decision 1b)', () => {
     )
   })
 
-  it('co-registering the v2 and v3 descriptors throws on the shared method names', () => {
-    // Both descriptors define `cipherstashEq` (and eleven siblings); the
-    // flat, method-keyed OperationRegistry disallows override. This is
-    // WHY v2 and v3 are separate entry points that are never composed
-    // into one client. The registry is assembled when the execution
-    // context is built against a contract, so the collision surfaces
-    // there rather than at adapter construction.
-    expect(() =>
-      assembleV3ExecutionContext([
-        createCipherstashRuntimeDescriptor({ sdk: emptySdk() }),
-        v3RuntimeDescriptor(),
-      ]),
-    ).toThrow(/already registered/)
+  it('the v2 and v3 operator method-name sets are disjoint', () => {
+    // The v3 registry speaks the EQL-derived `eql*` vocabulary, v2
+    // keeps its historical `cipherstash*` names (PR #655 review). No
+    // shared key means the flat, method-keyed OperationRegistry can
+    // never confuse the two surfaces — generation identity is fixed at
+    // client construction (decision 1b), not resolved per method name.
+    const v2Methods = Object.keys(cipherstashQueryOperations())
+    const v3Methods = Object.keys(cipherstashV3QueryOperations())
+    expect(v2Methods.length).toBeGreaterThan(0)
+    expect(v3Methods.length).toBeGreaterThan(0)
+    const v2Set = new Set(v2Methods)
+    expect(v3Methods.filter((method) => v2Set.has(method))).toEqual([])
+    const v3Set = new Set(v3Methods)
+    expect(v2Methods.filter((method) => v3Set.has(method))).toEqual([])
+    // The naming split is total, not incidental: every v3 method wears
+    // the `eql` prefix, no v2 method does.
+    expect(v3Methods.every((method) => method.startsWith('eql'))).toBe(true)
+    expect(v2Methods.every((method) => method.startsWith('cipherstash'))).toBe(
+      true,
+    )
   })
 })
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
index 35a87496..04d9a9f7 100644
--- a/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-equality.test.ts
@@ -1,6 +1,6 @@
 /**
- * v3 operator lowering — equality family (`cipherstashEq`,
- * `cipherstashNe`, `cipherstashInArray`, `cipherstashNotInArray`).
+ * v3 operator lowering — equality family (`eqlEq`,
+ * `eqlNeq`, `eqlIn`, `eqlNotIn`).
  *
  * The canonical v3 dialect (mirrors
  * `packages/stack-drizzle/src/v3/{operators,sql-dialect}.ts`):
@@ -40,10 +40,10 @@ import {
   TEXT_SEARCH_CODEC_ID,
 } from './operator-lowering-v3.helpers'
 
-describe('cipherstash v3 operator lowering — cipherstashEq', () => {
-  it('lowers nickname.cipherstashEq(plaintext) to eql_v3.eq(col, $1::eql_v3.query_text_eq)', () => {
+describe('cipherstash v3 operator lowering — eqlEq', () => {
+  it('lowers nickname.eqlEq(plaintext) to eql_v3.eq(col, $1::eql_v3.query_text_eq)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashEq'),
+      getOperator('eqlEq'),
       columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
       'alice',
     )
@@ -55,9 +55,9 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
     )
   })
 
-  it('lowers email.cipherstashEq on a text_search column with the query_text_search cast', () => {
+  it('lowers email.eqlEq on a text_search column with the query_text_search cast', () => {
     const predicate = callOperator(
-      getOperator('cipherstashEq'),
+      getOperator('eqlEq'),
       columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
       'alice@example.com',
     )
@@ -71,7 +71,7 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
 
   it('accepts equality on an OPE-ordered domain (integer_ord answers equality via its ordering term)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashEq'),
+      getOperator('eqlEq'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       42,
     )
@@ -85,7 +85,7 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
 
   it('binds the plaintext as an envelope stamped with the routing key and the equality query-term mark', () => {
     const predicate = callOperator(
-      getOperator('cipherstashEq'),
+      getOperator('eqlEq'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       42,
     )
@@ -108,7 +108,7 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
   it('passes a pre-built envelope through unchanged (advanced caller path)', () => {
     const userEnvelope = EncryptedString.from('alice')
     const predicate = callOperator(
-      getOperator('cipherstashEq'),
+      getOperator('eqlEq'),
       columnAccessorV3(TABLE, 'nickname', TEXT_EQ_CODEC_ID),
       userEnvelope,
     )
@@ -125,14 +125,14 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
   it('rejects a plaintext that does not match the domain castAs with a specific diagnostic', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         'not-a-number',
       ),
     ).toThrow(EncryptionOperatorError)
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         'not-a-number',
       ),
@@ -142,7 +142,7 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
   it('rejects a null operand with an isNull() hint', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         null,
       ),
@@ -150,10 +150,10 @@ describe('cipherstash v3 operator lowering — cipherstashEq', () => {
   })
 })
 
-describe('cipherstash v3 operator lowering — cipherstashNe', () => {
+describe('cipherstash v3 operator lowering — eqlNeq', () => {
   it('lowers to eql_v3.neq(col, $1::eql_v3.query_<domain>)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashNe'),
+      getOperator('eqlNeq'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       42,
     )
@@ -169,10 +169,10 @@ describe('cipherstash v3 operator lowering — cipherstashNe', () => {
   })
 })
 
-describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashNotInArray', () => {
+describe('cipherstash v3 operator lowering — eqlIn / eqlNotIn', () => {
   it('lowers a single-element inArray to a one-term OR (outer parens retained)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashInArray'),
+      getOperator('eqlIn'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       [1],
     )
@@ -186,7 +186,7 @@ describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashN
 
   it('lowers a two-element inArray to an OR of eq terms, one query-term param per value', () => {
     const predicate = callOperator(
-      getOperator('cipherstashInArray'),
+      getOperator('eqlIn'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       [1, 2],
     )
@@ -207,9 +207,9 @@ describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashN
     }
   })
 
-  it('lowers cipherstashNotInArray to NOT-prefixed OR-of-equalities (whole disjunction negated)', () => {
+  it('lowers eqlNotIn to NOT-prefixed OR-of-equalities (whole disjunction negated)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashNotInArray'),
+      getOperator('eqlNotIn'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       [1, 2],
     )
@@ -224,7 +224,7 @@ describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashN
   it('rejects empty arrays with a descriptive error', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashInArray'),
+        getOperator('eqlIn'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         [],
       ),
@@ -234,7 +234,7 @@ describe('cipherstash v3 operator lowering — cipherstashInArray / cipherstashN
   it('rejects non-array arguments with a descriptive error', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashInArray'),
+        getOperator('eqlIn'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         'not-an-array',
       ),
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
index 7220d177..cb83c48c 100644
--- a/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-json.test.ts
@@ -1,6 +1,6 @@
 /**
  * v3 operator lowering — encrypted-JSONB containment
- * (`cipherstashJsonContains`, trait `cipherstash:searchable-json`).
+ * (`eqlJsonContains`, trait `cipherstash:searchable-json`).
  *
  * Canonical dialect (mirrors `v3Dialect.containsJson` in
  * `packages/stack-drizzle/src/v3/sql-dialect.ts`): `eql_v3_json` has NO
@@ -15,7 +15,7 @@
  * be ambiguous ("operator is not unique", 42725) — the explicit cast
  * is load-bearing.
  *
- * Unlike the bloom `cipherstashIlike`, this is EXACT jsonb containment:
+ * Unlike the bloom `eqlMatch`, this is EXACT jsonb containment:
  * no false positives. This is the drizzle reference's full JSON
  * operator surface (`contains`); the reference exposes neither a
  * containedBy direction nor selector querying, so neither is
@@ -40,10 +40,10 @@ import {
   TABLE,
 } from './operator-lowering-v3.helpers'
 
-describe('cipherstash v3 operator lowering — cipherstashJsonContains', () => {
+describe('cipherstash v3 operator lowering — eqlJsonContains', () => {
   it('lowers to col OPERATOR(public.@>) $1::eql_v3.query_jsonb', () => {
     const predicate = callOperator(
-      getOperator('cipherstashJsonContains'),
+      getOperator('eqlJsonContains'),
       columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
       { role: 'admin' },
     )
@@ -57,7 +57,7 @@ describe('cipherstash v3 operator lowering — cipherstashJsonContains', () => {
 
   it('binds the needle as an EncryptedJson envelope with the searchableJson query-term mark', () => {
     const predicate = callOperator(
-      getOperator('cipherstashJsonContains'),
+      getOperator('eqlJsonContains'),
       columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
       { role: 'admin' },
     )
@@ -79,7 +79,7 @@ describe('cipherstash v3 operator lowering — cipherstashJsonContains', () => {
     // the same whole-table footgun the drizzle reference guards.
     expect(() =>
       callOperator(
-        getOperator('cipherstashJsonContains'),
+        getOperator('eqlJsonContains'),
         columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
         {},
       ),
@@ -89,10 +89,18 @@ describe('cipherstash v3 operator lowering — cipherstashJsonContains', () => {
   it('rejects a null needle with an isNull() hint', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashJsonContains'),
+        getOperator('eqlJsonContains'),
         columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
         null,
       ),
     ).toThrow(EncryptionOperatorError)
+    // The hint must actually name the NULL-check alternative.
+    expect(() =>
+      callOperator(
+        getOperator('eqlJsonContains'),
+        columnAccessorV3(TABLE, 'payload', JSON_CODEC_ID),
+        null,
+      ),
+    ).toThrow(/isNull\(\)/)
   })
 })
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
index b7ef6d89..09b53b15 100644
--- a/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-order-range.test.ts
@@ -1,7 +1,7 @@
 /**
- * v3 operator lowering — order/range family (`cipherstashGt` / `Gte` /
+ * v3 operator lowering — order/range family (`eqlGt` / `Gte` /
  * `Lt` / `Lte` / `Between` / `NotBetween`) plus the free-standing
- * ordering helpers (`cipherstashV3Asc` / `cipherstashV3Desc`).
+ * ordering helpers (`eqlAsc` / `eqlDesc`).
  *
  * Canonical dialect (mirrors `packages/stack-drizzle/src/v3/sql-dialect.ts`):
  *
@@ -20,11 +20,7 @@
 import { describe, expect, it } from 'vitest'
 import { EncryptedBigInt } from '../../src/execution/envelope-bigint'
 import { EncryptedNumber } from '../../src/v3/envelope-number'
-import {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
-  v3QueryTermTypeOf,
-} from '../../src/v3/operators-v3'
+import { eqlAsc, eqlDesc, v3QueryTermTypeOf } from '../../src/v3/operators-v3'
 import {
   BIGINT_ORD_ORE_CODEC_ID,
   callOperator,
@@ -41,10 +37,10 @@ import {
 
 describe('cipherstash v3 operator lowering — comparisons', () => {
   it.each([
-    ['cipherstashGt', 'gt'],
-    ['cipherstashGte', 'gte'],
-    ['cipherstashLt', 'lt'],
-    ['cipherstashLte', 'lte'],
+    ['eqlGt', 'gt'],
+    ['eqlGte', 'gte'],
+    ['eqlLt', 'lt'],
+    ['eqlLte', 'lte'],
   ] as const)('%s lowers to eql_v3.%s(col, $1::eql_v3.query_integer_ord)', (method, fn) => {
     const predicate = callOperator(
       getOperator(method),
@@ -64,7 +60,7 @@ describe('cipherstash v3 operator lowering — comparisons', () => {
 
   it('casts to the ord_ore query domain on a block-ORE column (bigint envelope dispatch)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashGt'),
+      getOperator('eqlGt'),
       columnAccessorV3(TABLE, 'balance', BIGINT_ORD_ORE_CODEC_ID),
       100n,
     )
@@ -79,9 +75,9 @@ describe('cipherstash v3 operator lowering — comparisons', () => {
 })
 
 describe('cipherstash v3 operator lowering — between / notBetween', () => {
-  it('cipherstashBetween is a SELF-PARENTHESISED conjunction (composition-safe)', () => {
+  it('eqlBetween is a SELF-PARENTHESISED conjunction (composition-safe)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashBetween'),
+      getOperator('eqlBetween'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       1,
       9,
@@ -103,9 +99,9 @@ describe('cipherstash v3 operator lowering — between / notBetween', () => {
     ).toBe(9)
   })
 
-  it('cipherstashNotBetween wraps the WHOLE conjunction: NOT (gte AND lte)', () => {
+  it('eqlNotBetween wraps the WHOLE conjunction: NOT (gte AND lte)', () => {
     const predicate = callOperator(
-      getOperator('cipherstashNotBetween'),
+      getOperator('eqlNotBetween'),
       columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
       1,
       9,
@@ -121,10 +117,10 @@ describe('cipherstash v3 operator lowering — between / notBetween', () => {
     expect(lowered.sql).not.toMatch(/NOT eql_v3\.gte/)
   })
 
-  it('cipherstashBetween enforces its 2-argument arity', () => {
+  it('eqlBetween enforces its 2-argument arity', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashBetween'),
+        getOperator('eqlBetween'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
         1,
       ),
@@ -132,11 +128,9 @@ describe('cipherstash v3 operator lowering — between / notBetween', () => {
   })
 })
 
-describe('cipherstash v3 ordering — cipherstashV3Asc / cipherstashV3Desc', () => {
+describe('cipherstash v3 ordering — eqlAsc / eqlDesc', () => {
   it('lowers ASC on an OPE `_ord` column to ORDER BY eql_v3.ord_term(col) ASC', () => {
-    const item = cipherstashV3Asc(
-      columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID),
-    )
+    const item = eqlAsc(columnAccessorV3(TABLE, 'score', INTEGER_ORD_CODEC_ID))
     const lowered = makeV3Adapter().lower(selectWithOrderBy([item]), {
       contract: contractV3,
     })
@@ -147,7 +141,7 @@ describe('cipherstash v3 ordering — cipherstashV3Asc / cipherstashV3Desc', ()
   })
 
   it('lowers DESC on a block-ORE `_ord_ore` column to ORDER BY eql_v3.ord_term_ore(col) DESC', () => {
-    const item = cipherstashV3Desc(
+    const item = eqlDesc(
       columnAccessorV3(TABLE, 'balance', BIGINT_ORD_ORE_CODEC_ID),
     )
     const lowered = makeV3Adapter().lower(selectWithOrderBy([item]), {
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts b/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
index 0bf0916b..486ab5bd 100644
--- a/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
+++ b/packages/prisma-next/test/v3/operator-lowering-v3-text-search.test.ts
@@ -1,6 +1,5 @@
 /**
- * v3 operator lowering — free-text search family (`cipherstashIlike` /
- * `cipherstashNotIlike`).
+ * v3 operator lowering — free-text search (`eqlMatch`).
  *
  * Canonical dialect: `eql_v3.contains(<col>, $n::eql_v3.query_<domain>)`.
  * The SQL function keeps its bundle name `contains`, but the semantics
@@ -8,14 +7,33 @@
  * containment: the needle's downcased 3-gram set is tested as a subset
  * of the haystack's — order- and multiplicity-insensitive, and
  * one-sided (a `true` may be a false positive; a `false` never is).
- * The method names stay `cipherstashIlike` / `cipherstashNotIlike` to
- * mirror the v2 operator surface (decision 1b — same method names, v3
- * descriptor only).
+ *
+ * String needles are normalised and guarded BEFORE encryption
+ * (`normalizeMatchNeedle` in `src/v3/operators-v3.ts`):
+ *
+ *   - leading/trailing `%` are STRIPPED (an `ilike`-shaped habit like
+ *     `'%foo%'` still means "rows containing foo" under token
+ *     matching) — the stripped needle is what gets encrypted;
+ *   - an interior `%` or any `_` throws — the tokenizer would treat
+ *     them as ordinary characters and silently match nothing;
+ *   - a needle the column's match index cannot answer (empty after
+ *     stripping, or below the tokenizer's token length) is rejected
+ *     with the shared `matchNeedleError` reason (adapter-kit — same
+ *     guard as the Drizzle and Supabase v3 surfaces).
+ *
+ * There is NO negated match (`eql_v3.contains` may false-positive, so
+ * its negation would false-negative — silently dropping rows that
+ * genuinely don't match; PR #655 review). The registry must not expose
+ * one, pinned below.
  */
 
 import { describe, expect, it } from 'vitest'
 import { EncryptedString } from '../../src/execution/envelope-string'
-import { v3QueryTermTypeOf } from '../../src/v3/operators-v3'
+import {
+  cipherstashV3QueryOperations,
+  EncryptionOperatorError,
+  v3QueryTermTypeOf,
+} from '../../src/v3/operators-v3'
 import {
   callOperator,
   columnAccessorV3,
@@ -28,30 +46,28 @@ import {
   TEXT_SEARCH_CODEC_ID,
 } from './operator-lowering-v3.helpers'
 
-describe('cipherstash v3 operator lowering — cipherstashIlike', () => {
+/** Lower `email.eqlMatch(needle)` and return the SQL + bound envelope. */
+function lowerMatch(needle: unknown) {
+  const predicate = callOperator(
+    getOperator('eqlMatch'),
+    columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
+    needle,
+  )
+  return makeV3Adapter().lower(selectWithWhere(predicate), {
+    contract: contractV3,
+  })
+}
+
+describe('cipherstash v3 operator lowering — eqlMatch', () => {
   it('lowers to eql_v3.contains(col, $1::eql_v3.query_text_search)', () => {
-    const predicate = callOperator(
-      getOperator('cipherstashIlike'),
-      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
-      'alice',
-    )
-    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
-      contract: contractV3,
-    })
+    const lowered = lowerMatch('alice')
     expect(lowered.sql).toMatchInlineSnapshot(
       `"SELECT "user"."id" AS "id" FROM "user" WHERE eql_v3.contains("user"."email", $1::eql_v3.query_text_search)"`,
     )
   })
 
   it('binds the needle as an EncryptedString envelope with the freeTextSearch query-term mark', () => {
-    const predicate = callOperator(
-      getOperator('cipherstashIlike'),
-      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
-      'alice',
-    )
-    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
-      contract: contractV3,
-    })
+    const lowered = lowerMatch('alice')
     expect(lowered.params).toHaveLength(1)
     const envelope = literalParamValue(lowered.params[0])
     expect(envelope).toBeInstanceOf(EncryptedString)
@@ -65,18 +81,87 @@ describe('cipherstash v3 operator lowering — cipherstashIlike', () => {
   })
 })
 
-describe('cipherstash v3 operator lowering — cipherstashNotIlike', () => {
-  it('lowers to NOT eql_v3.contains(col, $1::eql_v3.query_text_search)', () => {
-    const predicate = callOperator(
-      getOperator('cipherstashNotIlike'),
-      columnAccessorV3(TABLE, 'email', TEXT_SEARCH_CODEC_ID),
-      'alice',
+describe('cipherstash v3 operator lowering — eqlMatch needle guards', () => {
+  it('strips leading/trailing % — the STRIPPED needle is what gets encrypted', () => {
+    const lowered = lowerMatch('%alice%')
+    expect(lowered.sql).toContain(
+      'eql_v3.contains("user"."email", $1::eql_v3.query_text_search)',
     )
-    const lowered = makeV3Adapter().lower(selectWithWhere(predicate), {
-      contract: contractV3,
-    })
-    expect(lowered.sql).toMatchInlineSnapshot(
-      `"SELECT "user"."id" AS "id" FROM "user" WHERE NOT eql_v3.contains("user"."email", $1::eql_v3.query_text_search)"`,
+    expect(lowered.params).toHaveLength(1)
+    const envelope = literalParamValue(lowered.params[0])
+    expect(envelope).toBeInstanceOf(EncryptedString)
+    // Not '%alice%': the SQL-wildcard shell is normalised away before
+    // the needle reaches encryption.
+    expect((envelope as EncryptedString).expose().plaintext).toBe('alice')
+  })
+
+  it('strips repeated and one-sided edge wildcards too', () => {
+    expect(
+      (
+        literalParamValue(lowerMatch('%%alice').params[0]) as EncryptedString
+      ).expose().plaintext,
+    ).toBe('alice')
+    expect(
+      (
+        literalParamValue(lowerMatch('alice%%%').params[0]) as EncryptedString
+      ).expose().plaintext,
+    ).toBe('alice')
+  })
+
+  it('rejects an interior % — the tokenizer cannot honor it', () => {
+    expect(() => lowerMatch('ali%ce')).toThrow(EncryptionOperatorError)
+    expect(() => lowerMatch('ali%ce')).toThrow(
+      /has wildcards fuzzy free-text matching cannot honor/,
+    )
+  })
+
+  it('rejects any _ wildcard, wherever it sits', () => {
+    for (const needle of ['ali_ce', '_alice', 'alice_']) {
+      expect(() => lowerMatch(needle), needle).toThrow(EncryptionOperatorError)
+      expect(() => lowerMatch(needle), needle).toThrow(
+        /has wildcards fuzzy free-text matching cannot honor/,
+      )
+    }
+  })
+
+  it('rejects a needle that is empty after stripping with the matchNeedleError reason', () => {
+    expect(() => lowerMatch('%%')).toThrow(EncryptionOperatorError)
+    expect(() => lowerMatch('%%')).toThrow(
+      /^Operator "eqlMatch" cannot search column "email"/,
+    )
+    expect(() => lowerMatch('%%')).toThrow(/non-empty search term/)
+  })
+
+  it('rejects a needle below the match index token length with the matchNeedleError reason', () => {
+    // The catalog's text_search match index tokenizes 3-grams; a
+    // 2-codepoint needle blooms to nothing and would match EVERY row.
+    expect(() => lowerMatch('ab')).toThrow(EncryptionOperatorError)
+    expect(() => lowerMatch('ab')).toThrow(
+      /^Operator "eqlMatch" cannot search column "email"/,
     )
+    expect(() => lowerMatch('%ab%')).toThrow(/at least 3 characters/)
+  })
+
+  it('passes a pre-built envelope through ungated (non-string operands skip the needle guards)', () => {
+    // Envelope operands fall through to coerceV3 — the guard only
+    // normalises raw string needles.
+    const userEnvelope = EncryptedString.from('%alice%')
+    const lowered = lowerMatch(userEnvelope)
+    expect(literalParamValue(lowered.params[0])).toBe(userEnvelope)
+    expect(userEnvelope.expose().plaintext).toBe('%alice%')
+  })
+})
+
+describe('cipherstash v3 registry — no negated match', () => {
+  it('exposes neither eqlNotMatch nor the removed cipherstashNotIlike', () => {
+    // `eql_v3.contains` is one-sided (may false-positive), so a negated
+    // form would FALSE-NEGATIVE — silently dropping rows that genuinely
+    // don't match. Until a decrypt-and-post-filter path exists, the
+    // registry must not offer one (PR #655 review; same removal as the
+    // Drizzle/Supabase v3 surfaces).
+    const methods = Object.keys(cipherstashV3QueryOperations())
+    expect(methods).not.toContain('eqlNotMatch')
+    expect(methods).not.toContain('cipherstashNotIlike')
+    expect(methods).toContain('eqlMatch')
   })
 })
diff --git a/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts b/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts
index 8bfd2438..35831df5 100644
--- a/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts
+++ b/packages/prisma-next/test/v3/operator-lowering-v3.helpers.ts
@@ -10,8 +10,8 @@
  *     `createCipherstashV3RuntimeDescriptor` will productionise this
  *     exact shape; the inline copy keeps the operator tests decoupled
  *     from that task. The v2 descriptor is NEVER co-registered here —
- *     decision 1b (the flat `OperationRegistry` rejects two descriptors
- *     sharing the `cipherstashEq` method name; pinned in
+ *     decision 1b (a client is v2 or v3 by construction; the v2
+ *     `cipherstash*` and v3 `eql*` method sets are disjoint, pinned in
  *     `operator-gating-v3.test.ts`).
  *   - **Contract columns**: each v3 column carries its concrete
  *     `public.eql_v3_*` domain as `nativeType` plus the
@@ -202,8 +202,8 @@ export function makeV3Adapter(
  * Assemble a full SQL execution context (contract + stack) — the step
  * that builds the flat `OperationRegistry` from every contributor's
  * `queryOperations()`. This is where a duplicate method name across
- * extension packs throws (`adapter.lower` alone never touches the
- * registry), so the decision-1b co-registration pin drives this path.
+ * extension packs would throw (`adapter.lower` alone never touches the
+ * registry), so the decision-1b registration pins drive this path.
  */
 export function assembleV3ExecutionContext(
   extensionPacks: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>> = [
diff --git a/packages/prisma-next/test/v3/properties.test.ts b/packages/prisma-next/test/v3/properties.test.ts
index 5b61111d..18a3993a 100644
--- a/packages/prisma-next/test/v3/properties.test.ts
+++ b/packages/prisma-next/test/v3/properties.test.ts
@@ -65,9 +65,9 @@ import {
 import { deriveStackSchemasV3 } from '../../src/v3/derive-schemas-v3'
 import { EncryptedNumber } from '../../src/v3/envelope-number'
 import {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   EncryptionOperatorError,
+  eqlAsc,
+  eqlDesc,
 } from '../../src/v3/operators-v3'
 import { v3FromDriver, v3ToDriver } from '../../src/v3/wire-v3'
 import {
@@ -342,51 +342,48 @@ describe('property: operator-gating totality (every domain × every operator)',
     capability: CapabilityKey
     args: (value: unknown) => unknown[]
   }> = [
-    { method: 'cipherstashEq', capability: 'equality', args: (v) => [v] },
-    { method: 'cipherstashNe', capability: 'equality', args: (v) => [v] },
+    { method: 'eqlEq', capability: 'equality', args: (v) => [v] },
+    { method: 'eqlNeq', capability: 'equality', args: (v) => [v] },
     {
-      method: 'cipherstashInArray',
+      method: 'eqlIn',
       capability: 'equality',
       args: (v) => [[v, v]],
     },
     {
-      method: 'cipherstashNotInArray',
+      method: 'eqlNotIn',
       capability: 'equality',
       args: (v) => [[v]],
     },
-    { method: 'cipherstashGt', capability: 'orderAndRange', args: (v) => [v] },
-    { method: 'cipherstashGte', capability: 'orderAndRange', args: (v) => [v] },
-    { method: 'cipherstashLt', capability: 'orderAndRange', args: (v) => [v] },
-    { method: 'cipherstashLte', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'eqlGt', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'eqlGte', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'eqlLt', capability: 'orderAndRange', args: (v) => [v] },
+    { method: 'eqlLte', capability: 'orderAndRange', args: (v) => [v] },
     {
-      method: 'cipherstashBetween',
+      method: 'eqlBetween',
       capability: 'orderAndRange',
       args: (v) => [v, v],
     },
     {
-      method: 'cipherstashNotBetween',
+      method: 'eqlNotBetween',
       capability: 'orderAndRange',
       args: (v) => [v, v],
     },
+    // No negated match case: the v3 registry deliberately exposes no
+    // `eqlNotMatch` (bloom negation false-negatives; PR #655 review).
     {
-      method: 'cipherstashIlike',
+      method: 'eqlMatch',
       capability: 'freeTextSearch',
       args: (v) => [v],
     },
     {
-      method: 'cipherstashNotIlike',
-      capability: 'freeTextSearch',
-      args: (v) => [v],
-    },
-    {
-      method: 'cipherstashJsonContains',
+      method: 'eqlJsonContains',
       capability: 'searchableJson',
       args: (v) => [v],
     },
   ]
 
   it('each pair either lowers with the canonical query cast or throws EncryptionOperatorError, decided by the capability', () => {
-    // The (domain × operator) grid is finite and small (40 × 13), so it
+    // The (domain × operator) grid is finite and small (40 × 12), so it
     // is swept exhaustively — strictly stronger than random sampling.
     for (const [codecId, meta] of ALL_DOMAIN_ENTRIES) {
       for (const opCase of OPERATOR_CASES) {
@@ -406,7 +403,7 @@ describe('property: operator-gating totality (every domain × every operator)',
         // internal-invariant throw in requireQueryCast must be dead code.
         const template = templateOf(call())
         const cast =
-          opCase.method === 'cipherstashJsonContains'
+          opCase.method === 'eqlJsonContains'
             ? 'eql_v3.query_jsonb'
             : expectedQueryCast(meta)
         expect(template, label).toContain(`::${cast}`)
@@ -418,17 +415,17 @@ describe('property: operator-gating totality (every domain × every operator)',
     for (const [codecId, meta] of ALL_DOMAIN_ENTRIES) {
       const col = () => columnAccessorV3(TABLE, 'c', codecId)
       if (!meta.capabilities.orderAndRange) {
-        expect(() => cipherstashV3Asc(col()), meta.bareDomain).toThrow(
+        expect(() => eqlAsc(col()), meta.bareDomain).toThrow(
           EncryptionOperatorError,
         )
-        expect(() => cipherstashV3Desc(col()), meta.bareDomain).toThrow(
+        expect(() => eqlDesc(col()), meta.bareDomain).toThrow(
           EncryptionOperatorError,
         )
         continue
       }
       const fn = 'ore' in meta.indexes ? 'ord_term_ore' : 'ord_term'
-      const asc = cipherstashV3Asc(col())
-      const desc = cipherstashV3Desc(col())
+      const asc = eqlAsc(col())
+      const desc = eqlDesc(col())
       expect(asc.dir).toBe('asc')
       expect(desc.dir).toBe('desc')
       expect(templateOf(asc.expr), meta.bareDomain).toBe(
diff --git a/packages/prisma-next/test/v3/runtime-v3.test.ts b/packages/prisma-next/test/v3/runtime-v3.test.ts
index 8559229b..05928685 100644
--- a/packages/prisma-next/test/v3/runtime-v3.test.ts
+++ b/packages/prisma-next/test/v3/runtime-v3.test.ts
@@ -82,8 +82,8 @@ describe('createCipherstashV3RuntimeDescriptor — descriptor shape', () => {
     expect(methods.sort()).toEqual(
       Object.keys(cipherstashV3QueryOperations()).sort(),
     )
-    expect(methods).toContain('cipherstashEq')
-    expect(methods).toContain('cipherstashJsonContains')
+    expect(methods).toContain('eqlEq')
+    expect(methods).toContain('eqlJsonContains')
   })
 
   it('create() returns a target-bound SQL/Postgres instance', () => {

From 1a8d0dabc3bf3c281e2a04ed49cc8696fb80e629 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Thu, 16 Jul 2026 16:58:36 -0600
Subject: [PATCH 16/21] fix(prisma-next): PR #655 review hardening across the
 v3 seams
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- wire-v3: v3ToDriver coerces JSON.stringify's undefined branch to null;
  v3FromDriver gains overloads so a nullable input yields a nullable
  result instead of laundering null into T.
- sdk-adapter-v3: bulkDecrypt validates response cardinality (a
  truncated response would silently misalign plaintexts); the
  deliberate as-never bridges carry the repo's biome suppression.
- pack meta: extensionPacks.cipherstash now registers the 40 v3 codec
  metadata instances + storage rows (derived from the catalog, never
  hand-listed) and the EncryptedNumber type import, so consumer
  contracts describe the codecs their fields use.
- live suites: direct dotenv/config imports, canonical column-order
  binding in insertEncryptedRows (a differing key order could bind
  values to the wrong SQL columns), and migration-apply now uninstalls
  EQL v3 first so the customer-facing migration SQL genuinely executes
  on a reused database (test:live is serial now — the reinstall is
  destructive across files).
- bundling-isolation: entry checks scan the complete import graph for
  every v2 wire/codec-factory marker, not just entry bodies.

Verified live: 599 unit + 30 live-PG + 582 integration + 40 example-e2e
+ 7 README-walkthrough tests green against real ZeroKMS + Postgres.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/prisma-next/package.json             |   5 +-
 .../src/extension-metadata/codec-metadata.ts  |  72 ++++++++++++
 .../src/extension-metadata/descriptor-meta.ts |  15 +++
 packages/prisma-next/src/v3/sdk-adapter-v3.ts |  12 +-
 packages/prisma-next/src/v3/wire-v3.ts        |  19 +++-
 .../test/bundling-isolation.test.ts           | 104 +++++++++++++-----
 .../test/live/bigint-live-pg.test.ts          |  18 ++-
 .../test/live/boolean-storage-live-pg.test.ts |  28 ++---
 .../test/live/bulk-encrypt-live-pg.test.ts    |   1 +
 .../prisma-next/test/live/helpers/eql-v3.ts   |  28 +++++
 .../prisma-next/test/live/helpers/harness.ts  |  28 ++++-
 .../test/live/migration-apply-live-pg.test.ts |   9 +-
 .../test/live/operators-live-pg.test.ts       |  52 ++++-----
 .../test/live/operators-null-live-pg.test.ts  |   7 +-
 .../live/side-by-side-clients-live-pg.test.ts |   3 +-
 packages/prisma-next/vitest.config.ts         |   5 +-
 pnpm-lock.yaml                                |  18 ++-
 17 files changed, 331 insertions(+), 93 deletions(-)

diff --git a/packages/prisma-next/package.json b/packages/prisma-next/package.json
index 530fb172..bd5b6e5e 100644
--- a/packages/prisma-next/package.json
+++ b/packages/prisma-next/package.json
@@ -77,7 +77,8 @@
 		"dev": "tsup --watch",
 		"test": "vitest run",
 		"test:coverage": "vitest run --coverage",
-		"test:live": "vitest run test/live",
+		"test:live": "vitest run test/live --fileParallelism=false",
+		"test:integration": "vitest run --config integration/vitest.config.ts",
 		"typecheck": "tsc --project tsconfig.json --noEmit",
 		"lint": "biome check . --error-on-warnings",
 		"lint:fix": "biome check --write .",
@@ -99,6 +100,7 @@
 	},
 	"devDependencies": {
 		"@cipherstash/eql": "3.0.0",
+		"@cipherstash/test-kit": "workspace:*",
 		"@prisma-next/adapter-postgres": "0.14.0",
 		"@prisma-next/cli": "0.14.0",
 		"@prisma-next/driver-postgres": "0.14.0",
@@ -108,6 +110,7 @@
 		"@prisma-next/sql-contract-ts": "0.14.0",
 		"@prisma-next/sql-schema-ir": "0.14.0",
 		"@prisma-next/target-postgres": "0.14.0",
+		"dotenv": "17.4.2",
 		"fast-check": "^4.8.0",
 		"pathe": "^2.0.3",
 		"postgres": "^3.4.8",
diff --git a/packages/prisma-next/src/extension-metadata/codec-metadata.ts b/packages/prisma-next/src/extension-metadata/codec-metadata.ts
index 385b7b24..53ffe72d 100644
--- a/packages/prisma-next/src/extension-metadata/codec-metadata.ts
+++ b/packages/prisma-next/src/extension-metadata/codec-metadata.ts
@@ -26,7 +26,13 @@ import type { JsonValue } from '@prisma-next/contract/types'
 import {
   type AnyCodecDescriptor,
   CodecImpl,
+  type CodecTrait,
 } from '@prisma-next/framework-components/codec'
+import {
+  envelopeTypeNameForCastAs,
+  V3_DOMAIN_META_BY_CODEC_ID,
+  type V3DomainMeta,
+} from '../v3/catalog'
 import {
   CIPHERSTASH_BIGINT_CODEC_ID,
   CIPHERSTASH_BOOLEAN_CODEC_ID,
@@ -37,6 +43,7 @@ import {
   CIPHERSTASH_STRING_CODEC_ID,
   EQL_V2_ENCRYPTED_TYPE,
 } from './constants'
+import { v3TraitsForCapabilities } from './constants-v3'
 
 function makeMetadataDescriptor(
   codecId: string,
@@ -132,3 +139,68 @@ export const cipherstashJsonCodecMetadata = new CipherstashCodecMetadata(
   makeMetadataDescriptor(CIPHERSTASH_JSON_CODEC_ID, 'EncryptedJson'),
   'EncryptedJson',
 )
+
+// ---------------------------------------------------------------------------
+// EQL v3 — one metadata codec per catalog domain (all 40), DERIVED from the
+// catalog (never hand-listed) so pack-meta can never drift from what the
+// runtime registers. Mirrors the truthful metadata of the runtime auxiliary
+// descriptors in `../v3/codec-runtime-v3.ts` (traits from capabilities,
+// concrete `public.eql_v3_*` native type, `isParameterized: true` for the
+// static `{ castAs, capabilities }` typeParams block v3 authoring emits) —
+// minus the SDK-bound encode/decode, which pack-meta consumers never call.
+// The catalog import stays SDK/envelope-free, preserving the control-vs-
+// runtime bundling split this module's header describes.
+// ---------------------------------------------------------------------------
+
+function makeV3MetadataDescriptor(
+  codecId: string,
+  meta: V3DomainMeta,
+  typeName: string,
+): AnyCodecDescriptor {
+  return {
+    codecId,
+    // Type-level adapter into the framework's closed `CodecTrait` union —
+    // same rationale as `v3CodecTraits` in `../v3/codec-runtime-v3.ts`.
+    traits: v3TraitsForCapabilities(meta.capabilities) as readonly CodecTrait[],
+    targetTypes: [meta.nativeType],
+    meta: { db: { sql: { postgres: { nativeType: meta.nativeType } } } },
+    paramsSchema: {
+      '~standard': {
+        version: 1,
+        vendor: 'cipherstash',
+        validate: (value: unknown) => ({ value }),
+      },
+    },
+    isParameterized: true,
+    renderOutputType: () => typeName,
+    factory: () => () => {
+      throw new Error(
+        'cipherstash codec: metadata descriptor factory is not callable',
+      )
+    },
+  }
+}
+
+/** All 40 v3 metadata codecs, in catalog order. */
+export const cipherstashV3CodecMetadataInstances: readonly CipherstashCodecMetadata[] =
+  [...V3_DOMAIN_META_BY_CODEC_ID.entries()].map(([codecId, meta]) => {
+    const typeName = envelopeTypeNameForCastAs(meta.castAs)
+    return new CipherstashCodecMetadata(
+      makeV3MetadataDescriptor(codecId, meta, typeName),
+      typeName,
+    )
+  })
+
+/** Pack-meta `types.storage` rows for the v3 codecs — one per domain,
+ * each targeting its own concrete `public.eql_v3_*` native type. */
+export const cipherstashV3StorageRows: ReadonlyArray<{
+  readonly typeId: string
+  readonly familyId: 'sql'
+  readonly targetId: 'postgres'
+  readonly nativeType: string
+}> = [...V3_DOMAIN_META_BY_CODEC_ID.entries()].map(([codecId, meta]) => ({
+  typeId: codecId,
+  familyId: 'sql',
+  targetId: 'postgres',
+  nativeType: meta.nativeType,
+}))
diff --git a/packages/prisma-next/src/extension-metadata/descriptor-meta.ts b/packages/prisma-next/src/extension-metadata/descriptor-meta.ts
index d6adc835..4b2f2bb8 100644
--- a/packages/prisma-next/src/extension-metadata/descriptor-meta.ts
+++ b/packages/prisma-next/src/extension-metadata/descriptor-meta.ts
@@ -29,6 +29,8 @@ import {
   cipherstashDoubleCodecMetadata,
   cipherstashJsonCodecMetadata,
   cipherstashStringCodecMetadata,
+  cipherstashV3CodecMetadataInstances,
+  cipherstashV3StorageRows,
 } from './codec-metadata'
 import {
   CIPHERSTASH_BIGINT_CODEC_ID,
@@ -62,6 +64,8 @@ export const cipherstashPackMeta = {
         cipherstashDateCodecMetadata,
         cipherstashBooleanCodecMetadata,
         cipherstashJsonCodecMetadata,
+        // EQL v3 — all 40 catalog domains, derived (see codec-metadata.ts).
+        ...cipherstashV3CodecMetadataInstances,
       ],
       // Drives the contract emitter to add
       //   `import type { CodecTypes as CipherstashTypes } from '@prisma-next/extension-cipherstash/codec-types'`
@@ -113,6 +117,14 @@ export const cipherstashPackMeta = {
           named: 'EncryptedJson',
           alias: 'EncryptedJson',
         },
+        // v3-only envelope (every numeric v3 domain renders as
+        // `EncryptedNumber`; the other v3 domains reuse the
+        // version-neutral envelope classes already imported above).
+        {
+          package: '@prisma-next/extension-cipherstash/runtime',
+          named: 'EncryptedNumber',
+          alias: 'EncryptedNumber',
+        },
       ],
     },
     queryOperationTypes: {
@@ -159,6 +171,9 @@ export const cipherstashPackMeta = {
         targetId: 'postgres',
         nativeType: EQL_V2_ENCRYPTED_TYPE,
       },
+      // EQL v3 — one row per catalog domain, each targeting its own
+      // concrete `public.eql_v3_*` native type (see codec-metadata.ts).
+      ...cipherstashV3StorageRows,
     ],
   },
 } as const
diff --git a/packages/prisma-next/src/v3/sdk-adapter-v3.ts b/packages/prisma-next/src/v3/sdk-adapter-v3.ts
index 37c4c501..fbdac05d 100644
--- a/packages/prisma-next/src/v3/sdk-adapter-v3.ts
+++ b/packages/prisma-next/src/v3/sdk-adapter-v3.ts
@@ -218,6 +218,7 @@ export function createCipherstashV3Sdk(
         // `never` operands so the real client's GENERIC method satisfies
         // the structural surface (see the interface doc); the concrete
         // operand is re-widened at each call site.
+        // biome-ignore lint/plugin: deliberate bridge into the structural `never`-operand surface (rationale above)
         const result = await client.encryptQuery(terms as never)
         const data = unwrap(result, `encryptQuery(${queryType})`)
         if (data.length !== group.length) {
@@ -244,6 +245,7 @@ export function createCipherstashV3Sdk(
       await Promise.all(
         jsonTerms.map(async (slot) => {
           // Cast rationale: see the scalar branch above.
+          // biome-ignore lint/plugin: deliberate bridge into the structural `never`-operand surface (rationale above)
           const result = await client.encryptQuery(
             slot.plaintext as never,
             { table, column, queryType: 'searchableJson' } as never,
@@ -274,7 +276,15 @@ export function createCipherstashV3Sdk(
         data: ensureV3Payload(data, 'bulkDecrypt', index),
       }))
       const result = await client.bulkDecrypt(payload)
-      return unwrap(result, 'bulkDecrypt').map((entry) => {
+      const data = unwrap(result, 'bulkDecrypt')
+      // Same cardinality contract as bulkEncrypt above: a truncated
+      // response would silently misalign plaintexts with `ciphertexts`.
+      if (data.length !== ciphertexts.length) {
+        throw new Error(
+          `cipherstash v3 bulkDecrypt: client returned ${data.length} plaintexts for ${ciphertexts.length} ciphertexts.`,
+        )
+      }
+      return data.map((entry) => {
         if ('error' in entry && entry.error !== undefined) {
           throw new Error(
             `cipherstash v3 bulkDecrypt entry failed: ${String(entry.error)}`,
diff --git a/packages/prisma-next/src/v3/wire-v3.ts b/packages/prisma-next/src/v3/wire-v3.ts
index 0abb011c..6e4ee893 100644
--- a/packages/prisma-next/src/v3/wire-v3.ts
+++ b/packages/prisma-next/src/v3/wire-v3.ts
@@ -28,16 +28,27 @@ function bigintSafeReplacer(_key: string, value: unknown): unknown {
 /** Serialise an EQL payload to plain JSONB text; `null`/`undefined` → `null`. */
 export function v3ToDriver(value: unknown): string | null {
   if (value === null || value === undefined) return null
-  return JSON.stringify(value, bigintSafeReplacer)
+  // `JSON.stringify` returns `undefined` for unsupported top-level values
+  // (a function, a symbol, a lone `undefined` survivor of the replacer);
+  // coerce that branch to `null` so the declared contract holds.
+  return JSON.stringify(value, bigintSafeReplacer) ?? null
 }
 
 /**
  * Parse a JSONB wire back to the EQL payload. Text wires are
  * `JSON.parse`d; objects (drivers that pre-parse jsonb) pass through;
- * `null`/`undefined` are preserved as-is.
+ * `null`/`undefined` are preserved as-is — the overloads keep that
+ * passthrough visible to callers (a nullable input yields a nullable
+ * result) instead of laundering `null` into `T`.
  */
-export function v3FromDriver<T>(value: string | object | null | undefined): T {
-  if (value === null || value === undefined) return value as T
+export function v3FromDriver<T>(value: string | object): T
+export function v3FromDriver<T>(
+  value: string | object | null | undefined,
+): T | null | undefined
+export function v3FromDriver<T>(
+  value: string | object | null | undefined,
+): T | null | undefined {
+  if (value === null || value === undefined) return value
   if (typeof value === 'object') return value as T
   return JSON.parse(value) as T
 }
diff --git a/packages/prisma-next/test/bundling-isolation.test.ts b/packages/prisma-next/test/bundling-isolation.test.ts
index 238b6480..02889e5a 100644
--- a/packages/prisma-next/test/bundling-isolation.test.ts
+++ b/packages/prisma-next/test/bundling-isolation.test.ts
@@ -188,6 +188,21 @@ const V3_WIRE_MARKERS = [
   'bulkEncryptMiddlewareV3',
 ] as const
 
+/**
+ * The six v2 codec-RUNTIME factories (all built on the composite wire's
+ * `makeCipherstashCellCodec`). Distinct from {@link V2_WIRE_MARKERS} so
+ * the v3-graph scans can name exactly which factory leaked, and safe as
+ * substrings: no v3 identifier contains any of them.
+ */
+const V2_CODEC_FACTORY_MARKERS = [
+  'createCipherstashStringCodec',
+  'createCipherstashDoubleCodec',
+  'createCipherstashBigIntCodec',
+  'createCipherstashDateCodec',
+  'createCipherstashBooleanCodec',
+  'createCipherstashJsonCodec',
+] as const
+
 interface ChunkFile {
   readonly file: string
   readonly body: string
@@ -250,6 +265,45 @@ function isAllowedSharedChunk(chunk: string): boolean {
   )
 }
 
+/**
+ * Scan an entry's COMPLETE import graph (entry body + every transitive
+ * chunk) for forbidden markers, returning `"<chunk> → <marker>"`
+ * diagnostics so a failure names the offending chunk, not just the
+ * entry. `exempt` skips known-safe chunks (with the invariant that the
+ * exemption itself is pinned elsewhere — see the call sites).
+ */
+function findLeaksInGraph(
+  entry: string,
+  forbidden: readonly string[],
+  exempt: (chunk: ChunkFile) => boolean = () => false,
+): string[] {
+  const leaks: string[] = []
+  for (const [file, chunk] of collectGraph(entry)) {
+    if (exempt(chunk)) continue
+    for (const marker of forbidden) {
+      if (chunk.body.includes(marker)) {
+        leaks.push(`${file} → ${marker}`)
+      }
+    }
+  }
+  return leaks
+}
+
+/**
+ * The version-neutral execution chunk — envelope base/classes, routing,
+ * abort, `stampRoutingKeysFromAst` — is legitimately reachable from
+ * EVERY entry (the v3 middleware imports the shared routing walk), and
+ * it currently also DEFINES the v2 wire encoder. Identified by CONTENT
+ * (it is the one chunk that defines the envelope base class), never by
+ * tsup's hash-named file. It is exempted ONLY from the v2-wire-marker
+ * scan of the v3 graph; the per-chunk "no chunk mixes the two wires"
+ * test below still pins that this chunk never gains a v3 wire marker,
+ * so the exemption cannot hide a fused chunk.
+ */
+function definesVersionNeutralExecutionChunk(chunk: ChunkFile): boolean {
+  return /var EncryptedEnvelopeBase\s*=/.test(chunk.body)
+}
+
 describe('bundling isolation', () => {
   it('dist entry files exist (run `pnpm --filter @cipherstash/prisma-next build` first)', () => {
     for (const entry of ENTRY_FILES) {
@@ -298,39 +352,39 @@ describe('bundling isolation', () => {
     expect(leaks, `v3 entry leaks: ${leaks.join(', ')}`).toEqual([])
   })
 
-  it('v3.js does not pull the v2 composite-literal wire', () => {
-    const entry = readChunk('v3.js')
-    const leaks = findLeaksInEntry(entry, V2_WIRE_MARKERS)
-    expect(leaks, `v3 entry leaks v2 wire: ${leaks.join(', ')}`).toEqual([])
+  it('no chunk in the v3 graph references the v2 composite-literal wire (version-neutral execution chunk exempted)', () => {
+    // COMPLETE-graph scan, not just the entry body: a cross-plane leak
+    // usually arrives through a transitive chunk import, which an
+    // entry-body substring check never sees. `v3.js` legitimately
+    // shares the version-neutral execution chunk (envelope
+    // base/classes, routing, abort, `stampRoutingKeysFromAst`) with the
+    // v2 entries — that chunk currently also DEFINES the v2 wire
+    // encoder, so it is exempted here by content and pinned against v3
+    // contamination by the per-chunk disjointness test below.
+    const leaks = findLeaksInGraph(
+      'v3.js',
+      V2_WIRE_MARKERS,
+      definesVersionNeutralExecutionChunk,
+    )
+    expect(leaks, `v3 graph leaks v2 wire: ${leaks.join(', ')}`).toEqual([])
   })
 
-  it('the v3 entry graph never reaches the v2 codec-runtime chunk', () => {
-    // `v3.js` legitimately shares the version-neutral execution chunk
-    // (envelope base/classes, routing, abort, `stampRoutingKeysFromAst`)
-    // with the v2 entries — that chunk currently also DEFINES the v2
-    // wire encoder, which the per-chunk disjointness test below pins.
-    // What must never happen is the v3 graph importing the v2
-    // codec-RUNTIME chunk (the six `createCipherstash*Codec` factories
-    // built on the composite wire).
-    const v3Chunks = collectGraph('v3.js')
-    const offenders = [...v3Chunks.entries()]
-      .filter(([file]) => file !== 'v3.js')
-      .filter(([, chunk]) =>
-        chunk.body.includes('createCipherstashStringCodec'),
-      )
-      .map(([file]) => file)
+  it('no chunk in the v3 graph references any v2 codec-runtime factory', () => {
+    // All six `createCipherstash*Codec` factories (built on the
+    // composite wire), against every chunk in the v3 graph — including
+    // the version-neutral execution chunk, which must never grow one.
+    const leaks = findLeaksInGraph('v3.js', V2_CODEC_FACTORY_MARKERS)
     expect(
-      offenders,
-      `v3 graph reaches v2 codec-runtime chunk(s): ${offenders.join(', ')}`,
+      leaks,
+      `v3 graph reaches v2 codec-runtime factories: ${leaks.join(', ')}`,
     ).toEqual([])
   })
 
-  it('middleware.js (v2 bulk-encrypt entry) does not pull the v3 wire plane', () => {
-    const entry = readChunk('middleware.js')
-    const leaks = findLeaksInEntry(entry, V3_WIRE_MARKERS)
+  it('no chunk in the middleware.js graph (v2 bulk-encrypt entry) references the v3 wire plane', () => {
+    const leaks = findLeaksInGraph('middleware.js', V3_WIRE_MARKERS)
     expect(
       leaks,
-      `middleware entry leaks v3 wire: ${leaks.join(', ')}`,
+      `middleware graph leaks v3 wire: ${leaks.join(', ')}`,
     ).toEqual([])
   })
 
diff --git a/packages/prisma-next/test/live/bigint-live-pg.test.ts b/packages/prisma-next/test/live/bigint-live-pg.test.ts
index 71454c94..0daec66a 100644
--- a/packages/prisma-next/test/live/bigint-live-pg.test.ts
+++ b/packages/prisma-next/test/live/bigint-live-pg.test.ts
@@ -7,10 +7,11 @@
  * ordering terms order the real domain correctly.
  */
 
+import 'dotenv/config'
 import type postgres from 'postgres'
 import { afterAll, beforeAll, expect, it } from 'vitest'
 import { EncryptedBigInt } from '../../src/execution/envelope-bigint'
-import { cipherstashV3Asc } from '../../src/v3/operators-v3'
+import { eqlAsc } from '../../src/v3/operators-v3'
 import {
   callOperator,
   columnAccessorV3,
@@ -111,7 +112,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
     expect(negative).toBe(-7n)
   }, 60_000)
 
-  it('cipherstashEq on bigint_eq selects exactly the matching row', async () => {
+  it('eqlEq on bigint_eq selects exactly the matching row', async () => {
     const result = await runLoweredSelect(
       sql,
       live.middleware,
@@ -119,7 +120,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
       selectIdsWhere(
         TABLE,
         callOperator(
-          getOperator('cipherstashEq'),
+          getOperator('eqlEq'),
           columnAccessorV3(TABLE, 'balance_eq', BIGINT_EQ),
           UNSAFE_BIG,
         ),
@@ -135,10 +136,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
       sql,
       live.middleware,
       contract,
-      selectIdsWhere(
-        TABLE,
-        callOperator(getOperator('cipherstashGt'), ord(), 42n),
-      ),
+      selectIdsWhere(TABLE, callOperator(getOperator('eqlGt'), ord(), 42n)),
     )
     expect(gt.ids).toEqual(['huge'])
 
@@ -148,7 +146,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
       contract,
       selectIdsWhere(
         TABLE,
-        callOperator(getOperator('cipherstashBetween'), ord(), -100n, 100n),
+        callOperator(getOperator('eqlBetween'), ord(), -100n, 100n),
       ),
     )
     expect(between.ids.sort()).toEqual(['negative', 'small'])
@@ -160,7 +158,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
       live.middleware,
       contract,
       selectIdsOrderBy(TABLE, [
-        cipherstashV3Asc(columnAccessorV3(TABLE, 'balance_ord', BIGINT_ORD)),
+        eqlAsc(columnAccessorV3(TABLE, 'balance_ord', BIGINT_ORD)),
       ]),
     )
     expect(asc.sql).toContain('eql_v3.ord_term')
@@ -170,7 +168,7 @@ describeLivePg('v3 bigint domains against live Postgres', () => {
   it('the storage-only bigint domain refuses search operators', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'balance', BIGINT_STORAGE),
         42n,
       ),
diff --git a/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts b/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
index d647497c..8c3fb0cd 100644
--- a/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
+++ b/packages/prisma-next/test/live/boolean-storage-live-pg.test.ts
@@ -6,6 +6,7 @@
  * is no searchable term to mint.
  */
 
+import 'dotenv/config'
 import type postgres from 'postgres'
 import { afterAll, beforeAll, expect, it } from 'vitest'
 import { EncryptedBoolean } from '../../src/execution/envelope-boolean'
@@ -79,20 +80,21 @@ describeLivePg('v3 boolean storage against live Postgres', () => {
 
   it('every search operator throws EncryptionOperatorError on the storage-only domain', () => {
     const active = () => columnAccessorV3(TABLE, 'active', BOOLEAN)
+    // The full v3 registry — there is no negated match to attempt
+    // (`eqlNotMatch` deliberately does not exist).
     const attempts: ReadonlyArray<readonly [string, unknown[]]> = [
-      ['cipherstashEq', [true]],
-      ['cipherstashNe', [true]],
-      ['cipherstashInArray', [[true, false]]],
-      ['cipherstashNotInArray', [[true]]],
-      ['cipherstashGt', [false]],
-      ['cipherstashGte', [false]],
-      ['cipherstashLt', [true]],
-      ['cipherstashLte', [true]],
-      ['cipherstashBetween', [false, true]],
-      ['cipherstashNotBetween', [false, true]],
-      ['cipherstashIlike', ['tru']],
-      ['cipherstashNotIlike', ['tru']],
-      ['cipherstashJsonContains', [{ a: 1 }]],
+      ['eqlEq', [true]],
+      ['eqlNeq', [true]],
+      ['eqlIn', [[true, false]]],
+      ['eqlNotIn', [[true]]],
+      ['eqlGt', [false]],
+      ['eqlGte', [false]],
+      ['eqlLt', [true]],
+      ['eqlLte', [true]],
+      ['eqlBetween', [false, true]],
+      ['eqlNotBetween', [false, true]],
+      ['eqlMatch', ['tru']],
+      ['eqlJsonContains', [{ a: 1 }]],
     ]
     for (const [method, args] of attempts) {
       expect(
diff --git a/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts b/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
index 6aada625..8cebeb22 100644
--- a/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
+++ b/packages/prisma-next/test/live/bulk-encrypt-live-pg.test.ts
@@ -9,6 +9,7 @@
  * and every cell decrypts back to its original plaintext.
  */
 
+import 'dotenv/config'
 import type postgres from 'postgres'
 import { afterAll, beforeAll, expect, it } from 'vitest'
 import { EncryptedString } from '../../src/execution/envelope-string'
diff --git a/packages/prisma-next/test/live/helpers/eql-v3.ts b/packages/prisma-next/test/live/helpers/eql-v3.ts
index 6cd3eb98..1fd9ef2a 100644
--- a/packages/prisma-next/test/live/helpers/eql-v3.ts
+++ b/packages/prisma-next/test/live/helpers/eql-v3.ts
@@ -14,6 +14,7 @@
  * differs from the pinned release manifest.
  */
 
+import { readUninstallSql } from '@cipherstash/eql/sql'
 import type postgres from 'postgres'
 import {
   readInstallSql,
@@ -35,6 +36,33 @@ async function readEqlV3Version(
   return row?.version ?? null
 }
 
+/**
+ * Reset to a clean pre-install state, under the same advisory lock as
+ * the installer: run the release's own uninstall SQL (`DROP SCHEMA
+ * eql_v3 / eql_v3_internal CASCADE`), removing `eql_v3.version()` so a
+ * following {@link installEqlV3IfNeeded} MUST take the full install
+ * path instead of short-circuiting on the version probe. The
+ * `public.eql_v3_*` storage domains deliberately survive (the bundle
+ * creates them idempotently and application tables depend on them), so
+ * the other live suites' tables stay intact.
+ */
+export async function uninstallEqlV3(sql: postgres.Sql): Promise<void> {
+  const reserved = await sql.reserve()
+  try {
+    await reserved`SELECT pg_advisory_lock(${EQL_V3_ADVISORY_LOCK_ID})`
+    try {
+      await reserved.unsafe(readUninstallSql())
+      if ((await readEqlV3Version(reserved)) !== null) {
+        throw new Error('EQL v3 uninstall left eql_v3.version() behind')
+      }
+    } finally {
+      await reserved`SELECT pg_advisory_unlock(${EQL_V3_ADVISORY_LOCK_ID})`
+    }
+  } finally {
+    reserved.release()
+  }
+}
+
 export async function installEqlV3IfNeeded(sql: postgres.Sql): Promise<void> {
   // Advisory locks are session-scoped: reserve one physical connection
   // so lock and unlock land on the same session even though `postgres`
diff --git a/packages/prisma-next/test/live/helpers/harness.ts b/packages/prisma-next/test/live/helpers/harness.ts
index 8a297222..15e62ad4 100644
--- a/packages/prisma-next/test/live/helpers/harness.ts
+++ b/packages/prisma-next/test/live/helpers/harness.ts
@@ -198,6 +198,12 @@ export interface LiveRowSpec {
  * batches per-column `bulkEncrypt`/`encryptQuery` crossings, and
  * replaces envelope params with JSONB text), then execute against the
  * live database.
+ *
+ * Every row's params are bound in the FIRST row's column order (the
+ * canonical `cellColumns` list below): the INSERT column list is built
+ * once from the first row, so a later row iterated in its own
+ * `Object.entries` order could silently bind values to the wrong SQL
+ * columns. A row with a differing column set throws instead.
  */
 export async function insertEncryptedRows(
   sql: postgres.Sql,
@@ -207,15 +213,33 @@ export async function insertEncryptedRows(
 ): Promise<void> {
   const first = rows[0]
   if (!first) return
-  const columnNames = ['id', ...Object.keys(first.cells)]
+  const cellColumns = Object.keys(first.cells)
+  const columnNames = ['id', ...cellColumns]
 
   const params: unknown[] = []
   const astRows = rows.map((row) => {
+    const rowColumns = Object.keys(row.cells)
+    if (
+      rowColumns.length !== cellColumns.length ||
+      !cellColumns.every((column) => column in row.cells)
+    ) {
+      throw new Error(
+        `insertEncryptedRows: row "${row.id}" columns [${rowColumns.join(
+          ', ',
+        )}] do not match the first row's [${cellColumns.join(', ')}]`,
+      )
+    }
     const astRow: Record<string, ParamRef> = {}
     const idRef = ParamRef.of(row.id, { codec: { codecId: PG_TEXT } })
     astRow.id = idRef
     params.push(row.id)
-    for (const [column, cell] of Object.entries(row.cells)) {
+    for (const column of cellColumns) {
+      const cell = row.cells[column]
+      if (!cell) {
+        throw new Error(
+          `insertEncryptedRows: row "${row.id}" is missing column "${column}"`,
+        )
+      }
       const ref = ParamRef.of(cell.value, {
         codec: { codecId: cell.codecId },
       })
diff --git a/packages/prisma-next/test/live/migration-apply-live-pg.test.ts b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
index df00d603..ec4bb04a 100644
--- a/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
+++ b/packages/prisma-next/test/live/migration-apply-live-pg.test.ts
@@ -13,6 +13,7 @@
  * per-column search configuration).
  */
 
+import 'dotenv/config'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'pathe'
@@ -23,7 +24,7 @@ import {
   readInstallSql,
   releaseManifest,
 } from '../../src/migration/eql-bundle-v3'
-import { installEqlV3IfNeeded } from './helpers/eql-v3'
+import { installEqlV3IfNeeded, uninstallEqlV3 } from './helpers/eql-v3'
 import { liveConnection } from './helpers/harness'
 import { describeLivePg } from './helpers/live-gate'
 
@@ -65,6 +66,12 @@ describeLivePg('v3 baseline migration bundle against live Postgres', () => {
 
   beforeAll(async () => {
     sql = liveConnection()
+    // Reset to a clean pre-install state first: on a reused database
+    // `installEqlV3IfNeeded` would short-circuit on the version probe
+    // and this suite would never actually exercise the migration SQL.
+    // The uninstall removes `eql_v3.version()`, so the install below is
+    // guaranteed to apply the full bundle.
+    await uninstallEqlV3(sql)
     await installEqlV3IfNeeded(sql)
   }, 240_000)
 
diff --git a/packages/prisma-next/test/live/operators-live-pg.test.ts b/packages/prisma-next/test/live/operators-live-pg.test.ts
index 2ef5ae7a..93dbc847 100644
--- a/packages/prisma-next/test/live/operators-live-pg.test.ts
+++ b/packages/prisma-next/test/live/operators-live-pg.test.ts
@@ -7,13 +7,14 @@
  * (`@>` with `eql_v3.query_jsonb`).
  */
 
+import 'dotenv/config'
 import type postgres from 'postgres'
 import { afterAll, beforeAll, expect, it } from 'vitest'
 import { EncryptedDate } from '../../src/execution/envelope-date'
 import { EncryptedJson } from '../../src/execution/envelope-json'
 import { EncryptedString } from '../../src/execution/envelope-string'
 import { EncryptedNumber } from '../../src/v3/envelope-number'
-import { cipherstashV3Asc, cipherstashV3Desc } from '../../src/v3/operators-v3'
+import { eqlAsc, eqlDesc } from '../../src/v3/operators-v3'
 import {
   callOperator,
   columnAccessorV3,
@@ -140,10 +141,10 @@ describeLivePg('v3 operators against live Postgres', () => {
       selectIdsWhere(TABLE, predicate),
     )
 
-  it('cipherstashEq on a text_search column selects exactly the matching row', async () => {
+  it('eqlEq on a text_search column selects exactly the matching row', async () => {
     const result = await where(
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
         'grace@example.com',
       ),
@@ -153,31 +154,28 @@ describeLivePg('v3 operators against live Postgres', () => {
     expect(result.ids).toEqual(['grace'])
   }, 60_000)
 
-  it('cipherstashEq / cipherstashNe / cipherstashInArray on a text_eq column', async () => {
+  it('eqlEq / eqlNeq / eqlIn on a text_eq column', async () => {
     const nickname = () => columnAccessorV3(TABLE, 'nickname', TEXT_EQ)
     const eq = await where(
-      callOperator(getOperator('cipherstashEq'), nickname(), 'ada'),
+      callOperator(getOperator('eqlEq'), nickname(), 'ada'),
     )
     expect(eq.ids).toEqual(['ada'])
 
     const ne = await where(
-      callOperator(getOperator('cipherstashNe'), nickname(), 'ada'),
+      callOperator(getOperator('eqlNeq'), nickname(), 'ada'),
     )
     expect(ne.ids.sort()).toEqual(['grace', 'zora'])
 
     const inArray = await where(
-      callOperator(getOperator('cipherstashInArray'), nickname(), [
-        'ada',
-        'zora',
-      ]),
+      callOperator(getOperator('eqlIn'), nickname(), ['ada', 'zora']),
     )
     expect(inArray.ids.sort()).toEqual(['ada', 'zora'])
   }, 60_000)
 
-  it('cipherstashIlike lowers to eql_v3.contains and finds the token match', async () => {
+  it('eqlMatch lowers to eql_v3.contains and finds the token match', async () => {
     const result = await where(
       callOperator(
-        getOperator('cipherstashIlike'),
+        getOperator('eqlMatch'),
         columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
         'grace',
       ),
@@ -186,28 +184,24 @@ describeLivePg('v3 operators against live Postgres', () => {
     expect(result.ids).toEqual(['grace'])
   }, 60_000)
 
-  it('cipherstashGt / cipherstashLte / cipherstashBetween on integer_ord select the right rows', async () => {
+  it('eqlGt / eqlLte / eqlBetween on integer_ord select the right rows', async () => {
     const score = () => columnAccessorV3(TABLE, 'score', INTEGER_ORD)
-    const gt = await where(
-      callOperator(getOperator('cipherstashGt'), score(), 25),
-    )
+    const gt = await where(callOperator(getOperator('eqlGt'), score(), 25))
     expect(gt.ids).toEqual(['zora'])
 
-    const lte = await where(
-      callOperator(getOperator('cipherstashLte'), score(), 25),
-    )
+    const lte = await where(callOperator(getOperator('eqlLte'), score(), 25))
     expect(lte.ids.sort()).toEqual(['ada', 'grace'])
 
     const between = await where(
-      callOperator(getOperator('cipherstashBetween'), score(), 11, 40),
+      callOperator(getOperator('eqlBetween'), score(), 11, 40),
     )
     expect(between.ids.sort()).toEqual(['grace', 'zora'])
   }, 60_000)
 
-  it('cipherstashGt on date_ord and cipherstashBetween on timestamp_ord', async () => {
+  it('eqlGt on date_ord and eqlBetween on timestamp_ord', async () => {
     const bornAfter = await where(
       callOperator(
-        getOperator('cipherstashGt'),
+        getOperator('eqlGt'),
         columnAccessorV3(TABLE, 'birthday', DATE_ORD),
         new Date('1990-01-01T00:00:00Z'),
       ),
@@ -216,7 +210,7 @@ describeLivePg('v3 operators against live Postgres', () => {
 
     const seenIn2024 = await where(
       callOperator(
-        getOperator('cipherstashBetween'),
+        getOperator('eqlBetween'),
         columnAccessorV3(TABLE, 'seen_at', TIMESTAMP_ORD),
         new Date('2024-01-01T00:00:00Z'),
         new Date('2024-12-31T23:59:59Z'),
@@ -225,13 +219,13 @@ describeLivePg('v3 operators against live Postgres', () => {
     expect(seenIn2024.ids.sort()).toEqual(['ada', 'grace'])
   }, 60_000)
 
-  it('cipherstashV3Asc / Desc order by the encrypted order term', async () => {
+  it('eqlAsc / Desc order by the encrypted order term', async () => {
     const score = () => columnAccessorV3(TABLE, 'score', INTEGER_ORD)
     const asc = await runLoweredSelect(
       sql,
       live.middleware,
       contract,
-      selectIdsOrderBy(TABLE, [cipherstashV3Asc(score())]),
+      selectIdsOrderBy(TABLE, [eqlAsc(score())]),
     )
     expect(asc.sql).toContain('eql_v3.ord_term')
     expect(asc.ids).toEqual(['ada', 'grace', 'zora'])
@@ -240,15 +234,15 @@ describeLivePg('v3 operators against live Postgres', () => {
       sql,
       live.middleware,
       contract,
-      selectIdsOrderBy(TABLE, [cipherstashV3Desc(score())]),
+      selectIdsOrderBy(TABLE, [eqlDesc(score())]),
     )
     expect(desc.ids).toEqual(['zora', 'grace', 'ada'])
   }, 60_000)
 
-  it('cipherstashJsonContains (@> with eql_v3.query_jsonb) selects by encrypted containment', async () => {
+  it('eqlJsonContains (@> with eql_v3.query_jsonb) selects by encrypted containment', async () => {
     const result = await where(
       callOperator(
-        getOperator('cipherstashJsonContains'),
+        getOperator('eqlJsonContains'),
         columnAccessorV3(TABLE, 'payload', JSON_CODEC),
         { role: 'admin' },
       ),
@@ -259,7 +253,7 @@ describeLivePg('v3 operators against live Postgres', () => {
 
     const nested = await where(
       callOperator(
-        getOperator('cipherstashJsonContains'),
+        getOperator('eqlJsonContains'),
         columnAccessorV3(TABLE, 'payload', JSON_CODEC),
         { tags: ['compiler'] },
       ),
diff --git a/packages/prisma-next/test/live/operators-null-live-pg.test.ts b/packages/prisma-next/test/live/operators-null-live-pg.test.ts
index d4de8338..3c6a20fb 100644
--- a/packages/prisma-next/test/live/operators-null-live-pg.test.ts
+++ b/packages/prisma-next/test/live/operators-null-live-pg.test.ts
@@ -6,6 +6,7 @@
  * minting a nonsense query term.
  */
 
+import 'dotenv/config'
 import type postgres from 'postgres'
 import { afterAll, beforeAll, expect, it } from 'vitest'
 import { EncryptedString } from '../../src/execution/envelope-string'
@@ -87,7 +88,7 @@ describeLivePg('v3 null round-trips against live Postgres', () => {
       selectIdsWhere(
         TABLE,
         callOperator(
-          getOperator('cipherstashEq'),
+          getOperator('eqlEq'),
           columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
           'filled@example.com',
         ),
@@ -99,14 +100,14 @@ describeLivePg('v3 null round-trips against live Postgres', () => {
   it('operators reject a null operand with the isNull() hint', () => {
     expect(() =>
       callOperator(
-        getOperator('cipherstashEq'),
+        getOperator('eqlEq'),
         columnAccessorV3(TABLE, 'email', TEXT_SEARCH),
         null,
       ),
     ).toThrow(/isNull/)
     expect(() =>
       callOperator(
-        getOperator('cipherstashGt'),
+        getOperator('eqlGt'),
         columnAccessorV3(TABLE, 'score', INTEGER_ORD),
         null,
       ),
diff --git a/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
index f61eba20..a0b6c4f3 100644
--- a/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
+++ b/packages/prisma-next/test/live/side-by-side-clients-live-pg.test.ts
@@ -14,6 +14,7 @@
  * absent so the suite stays runnable against a v3-only database.
  */
 
+import 'dotenv/config'
 import type { PostgresContract } from '@prisma-next/adapter-postgres/types'
 import { validateSqlContractFully } from '@prisma-next/sql-contract/validators'
 import type postgres from 'postgres'
@@ -183,7 +184,7 @@ describeLivePg('v2 and v3 clients side by side against live Postgres', () => {
       selectIdsWhere(
         V3_TABLE,
         callOperator(
-          getOperator('cipherstashEq'),
+          getOperator('eqlEq'),
           columnAccessorV3(V3_TABLE, 'email', TEXT_SEARCH),
           V3_EMAIL,
         ),
diff --git a/packages/prisma-next/vitest.config.ts b/packages/prisma-next/vitest.config.ts
index c9c4d0f2..efacc548 100644
--- a/packages/prisma-next/vitest.config.ts
+++ b/packages/prisma-next/vitest.config.ts
@@ -1,9 +1,12 @@
-import { defineConfig } from 'vitest/config'
+import { configDefaults, defineConfig } from 'vitest/config'
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
+    // Integration suites run only under `test:integration` (own config +
+    // CI job) — same split as stack-drizzle / stack-supabase.
+    exclude: [...configDefaults.exclude, 'integration/**'],
     coverage: {
       provider: 'v8',
       reporter: ['text', 'json', 'html'],
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b74781e4..ff16c8ad 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -413,6 +413,9 @@ importers:
       '@cipherstash/eql':
         specifier: 3.0.0
         version: 3.0.0
+      '@cipherstash/test-kit':
+        specifier: workspace:*
+        version: link:../test-kit
       '@prisma-next/adapter-postgres':
         specifier: 0.14.0
         version: 0.14.0(typanion@3.14.0)(typescript@5.9.3)
@@ -440,9 +443,12 @@ importers:
       '@prisma-next/target-postgres':
         specifier: 0.14.0
         version: 0.14.0(typanion@3.14.0)(typescript@5.9.3)
+      dotenv:
+        specifier: 17.4.2
+        version: 17.4.2
       fast-check:
         specifier: ^4.8.0
-        version: 4.8.0
+        version: 4.9.0
       pathe:
         specifier: ^2.0.3
         version: 2.0.3
@@ -5166,6 +5172,14 @@ snapshots:
     optionalDependencies:
       vite: 7.3.6(@types/node@22.20.1)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.23.0)(yaml@2.9.0)
 
+  '@vitest/mocker@3.2.7(vite@7.3.6(@types/node@26.1.1)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.23.0)(yaml@2.9.0))':
+    dependencies:
+      '@vitest/spy': 3.2.7
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.6(@types/node@26.1.1)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.23.0)(yaml@2.9.0)
+
   '@vitest/pretty-format@3.2.7':
     dependencies:
       tinyrainbow: 2.0.0
@@ -6732,7 +6746,7 @@ snapshots:
     dependencies:
       '@types/chai': 5.2.3
       '@vitest/expect': 3.2.7
-      '@vitest/mocker': 3.2.7(vite@7.3.6(@types/node@22.20.1)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.23.0)(yaml@2.9.0))
+      '@vitest/mocker': 3.2.7(vite@7.3.6(@types/node@26.1.1)(jiti@2.7.0)(lightningcss@1.30.2)(terser@5.44.1)(tsx@4.23.0)(yaml@2.9.0))
       '@vitest/pretty-format': 3.2.7
       '@vitest/runner': 3.2.7
       '@vitest/snapshot': 3.2.7

From 69a2ef1f438471e3a87d856973ea078279d41b61 Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Thu, 16 Jul 2026 16:58:52 -0600
Subject: [PATCH 17/21] feat(prisma-example): adopt the eql* operator surface,
 regenerate the contract
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rename every v3 operator call to the EQL-derived vocabulary (eqlEq,
eqlMatch, eqlAsc/eqlDesc, …), fully qualify the README's domain table
(public.eql_v3_*), describe free-text search as fuzzy bloom token
matching under its real needle semantics, drop the removed
cipherstashNotIlike coverage, add a direct dotenv/config import to the
str-range suite, and remove the type-erasing probe assertions in the
bool suite. pnpm emit regenerates contract.{json,d.ts} — the
extensionPacks.cipherstash block now carries the 40 v3 codec instances
and storage rows.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/prisma-example-eql-v3.md           |    2 +-
 examples/prisma/README.md                     |   32 +-
 examples/prisma/prisma/schema.prisma          |    8 +-
 examples/prisma/src/index.ts                  |   40 +-
 examples/prisma/src/prisma/contract.d.ts      | 1210 +++++++++++++++
 examples/prisma/src/prisma/contract.json      | 1315 +++++++++++++++++
 examples/prisma/test/e2e/README.md            |    8 +-
 examples/prisma/test/e2e/bigint.e2e.test.ts   |   29 +-
 examples/prisma/test/e2e/bool.e2e.test.ts     |   63 +-
 examples/prisma/test/e2e/date.e2e.test.ts     |   29 +-
 examples/prisma/test/e2e/json.e2e.test.ts     |   32 +-
 examples/prisma/test/e2e/mixed.e2e.test.ts    |   18 +-
 examples/prisma/test/e2e/num.e2e.test.ts      |   40 +-
 .../prisma/test/e2e/str-range.e2e.test.ts     |   44 +-
 14 files changed, 2692 insertions(+), 178 deletions(-)

diff --git a/.changeset/prisma-example-eql-v3.md b/.changeset/prisma-example-eql-v3.md
index 955c2e07..c5b55055 100644
--- a/.changeset/prisma-example-eql-v3.md
+++ b/.changeset/prisma-example-eql-v3.md
@@ -2,4 +2,4 @@
 '@cipherstash/prisma-next-example': minor
 ---
 
-Convert the example app to EQL v3. Every column is now a concrete `public.eql_v3_*` domain authored with the per-domain constructors (`EncryptedTextSearch`, `EncryptedDoubleOrd`, `EncryptedBigIntOrd`, `EncryptedDateOrd`, `EncryptedBoolean`, `EncryptedJson`), wired through `cipherstashFromStackV3({ contractJson })`. The e2e harness runs the full v3 surface against live Postgres + ZeroKMS with no skips: equality/range/free-text-token operators, `cipherstashV3Asc`/`Desc` order-term sorting, encrypted JSON containment (`cipherstashJsonContains` — the v2 `cipherstashJsonb*` helpers do not exist in v3), lossless `bigint` beyond `Number.MAX_SAFE_INTEGER`, and the storage-only `eql_v3_boolean` refusal (`EncryptionOperatorError`) pinned as a feature. Migrations regenerate from the v3 contract: the initial app migration creates the `users` table against the v3 domains with zero `add_search_config` ops, and the cipherstash space carries both bundle baselines (v2 + v3).
+Convert the example app to EQL v3. Every column is now a concrete `public.eql_v3_*` domain authored with the per-domain constructors (`EncryptedTextSearch`, `EncryptedDoubleOrd`, `EncryptedBigIntOrd`, `EncryptedDateOrd`, `EncryptedBoolean`, `EncryptedJson`), wired through `cipherstashFromStackV3({ contractJson })`. The e2e harness runs the full v3 surface against live Postgres + ZeroKMS with no skips: the `eql*` operator vocabulary (equality/range plus `eqlMatch` free-text token search), `eqlAsc`/`eqlDesc` order-term sorting, encrypted JSON containment (`eqlJsonContains` — the v2 `cipherstashJsonb*` helpers do not exist in v3), lossless `bigint` beyond `Number.MAX_SAFE_INTEGER`, and the storage-only `eql_v3_boolean` refusal (`EncryptionOperatorError`) pinned as a feature. Migrations regenerate from the v3 contract: the initial app migration creates the `users` table against the v3 domains with zero `add_search_config` ops, and the cipherstash space carries both bundle baselines (v2 + v3).
diff --git a/examples/prisma/README.md b/examples/prisma/README.md
index 664ae274..723e6455 100644
--- a/examples/prisma/README.md
+++ b/examples/prisma/README.md
@@ -4,14 +4,14 @@ End-to-end demo of [`@cipherstash/prisma-next`](../../packages/prisma-next/READM
 
 A single `User` model with one column per plaintext family, exercised end-to-end: insert, equality, free-text token search, range, between, in-array, encrypted-order-term sort, JSON containment, and `decryptAll`-amortised read.
 
-| Column          | Constructor                       | Domain                | Query surface                          |
-| --------------- | --------------------------------- | --------------------- | -------------------------------------- |
-| `email`         | `cipherstash.EncryptedTextSearch()` | `eql_v3_text_search` | equality + order/range + free-text     |
-| `salary`        | `cipherstash.EncryptedDoubleOrd()`  | `eql_v3_double_ord`  | equality + order/range                 |
-| `accountId`     | `cipherstash.EncryptedBigIntOrd()`  | `eql_v3_bigint_ord`  | equality + order/range (true `bigint`) |
-| `birthday`      | `cipherstash.EncryptedDateOrd()`    | `eql_v3_date_ord`    | equality + order/range                 |
-| `emailVerified` | `cipherstash.EncryptedBoolean()`    | `eql_v3_boolean`     | storage-only (no operators)            |
-| `preferences`   | `cipherstash.EncryptedJson()`       | `eql_v3_json`        | `cipherstashJsonContains` (`@>`)       |
+| Column          | Constructor                       | Domain                      | Query surface                          |
+| --------------- | --------------------------------- | --------------------------- | -------------------------------------- |
+| `email`         | `cipherstash.EncryptedTextSearch()` | `public.eql_v3_text_search` | equality + order/range + free-text (`eqlMatch`) |
+| `salary`        | `cipherstash.EncryptedDoubleOrd()`  | `public.eql_v3_double_ord`  | equality + order/range                 |
+| `accountId`     | `cipherstash.EncryptedBigIntOrd()`  | `public.eql_v3_bigint_ord`  | equality + order/range (true `bigint`) |
+| `birthday`      | `cipherstash.EncryptedDateOrd()`    | `public.eql_v3_date_ord`    | equality + order/range                 |
+| `emailVerified` | `cipherstash.EncryptedBoolean()`    | `public.eql_v3_boolean`     | storage-only (no operators)            |
+| `preferences`   | `cipherstash.EncryptedJson()`       | `public.eql_v3_json`        | `eqlJsonContains` (`@>`)               |
 
 📖 See the [Prisma Next encryption docs](https://cipherstash.com/docs/stack/cipherstash/encryption/prisma-next) for the full operator reference, security model, and known limitations.
 
@@ -64,36 +64,36 @@ pnpm install && pnpm emit && pnpm typecheck
 --- Insert (mixed-domain round-trip) ---
 Inserted 4 rows across six cipherstash v3 domains.
 
---- cipherstashEq (text_search equality) ---
+--- eqlEq (text_search equality) ---
 Found 1 row(s) for alice@example.com.
   user-0: alice@example.com
 
---- cipherstashIlike (text_search free-text tokens) ---
+--- eqlMatch (text_search free-text tokens) ---
 Found 3 row(s) whose email contains example.com.
   user-0: alice@example.com
   user-1: bob@example.com
   user-2: carol@example.com
 
---- cipherstashGt (double_ord order-and-range) ---
+--- eqlGt (double_ord order-and-range) ---
 Found 2 user(s) with salary > 100,000.
   user-1: salary=110000
   user-3: salary=145000
 
---- cipherstashBetween (date_ord order-and-range) ---
+--- eqlBetween (date_ord order-and-range) ---
 Found 3 user(s) born between 1985 and 1995.
 
---- cipherstashInArray (bigint_ord equality) ---
+--- eqlIn (bigint_ord equality) ---
 Found 2 user(s) whose accountId is in the supplied array.
 
 --- eql_v3_boolean (storage-only round-trip) ---
   user-2: emailVerified=false
 
---- cipherstashJsonContains (encrypted jsonb @>) ---
+--- eqlJsonContains (encrypted jsonb @>) ---
 Found 2 user(s) with a dark-theme preference.
   user-0: {"theme":"dark","notifications":true}
   user-2: {"theme":"dark","notifications":true}
 
---- cipherstashV3Asc (encrypted order-term ORDER BY) ---
+--- eqlAsc (encrypted order-term ORDER BY) ---
   user-0: email=alice@example.com
   user-1: email=bob@example.com
   user-2: email=carol@example.com
@@ -102,7 +102,7 @@ Found 2 user(s) with a dark-theme preference.
 
 Two v3 behaviours worth noticing in that output:
 
-- **`cipherstashIlike` is bloom-filter token containment** (`eql_v3.contains`), not SQL `ILIKE` — the needle's tokens must appear in the ciphertext's index. Plain substrings like `example.com` are the idiomatic needle; `%` wildcards are not part of the model.
+- **`eqlMatch` is fuzzy bloom-filter token matching** (`eql_v3.contains`), not SQL `ILIKE` — the needle's tokens must appear in the ciphertext's index. Plain literal terms like `example.com` are the idiomatic needle: leading/trailing `%` are stripped for compatibility, while an interior `%` or any `_` throws (the tokenizer would treat them as ordinary characters), as do needles shorter than the match tokenizer length.
 - **`eql_v3_boolean` is storage-only.** It round-trips `true`/`false` losslessly but surfaces no search operators — calling one throws `EncryptionOperatorError`. Filter on a searchable column and decrypt the boolean from the result set.
 
 ## References
diff --git a/examples/prisma/prisma/schema.prisma b/examples/prisma/prisma/schema.prisma
index d009531e..349519b8 100644
--- a/examples/prisma/prisma/schema.prisma
+++ b/examples/prisma/prisma/schema.prisma
@@ -10,9 +10,9 @@
 //
 //   - email         (EncryptedTextSearch → eql_v3_text_search)
 //                     equality + order/range + free-text search:
-//                     cipherstashEq / Ne / InArray / NotInArray /
+//                     eqlEq / Neq / In / NotIn /
 //                     Gt / Gte / Lt / Lte / Between / NotBetween /
-//                     Ilike / NotIlike, cipherstashV3Asc / Desc.
+//                     Match, eqlAsc / Desc.
 //   - salary        (EncryptedDoubleOrd → eql_v3_double_ord)
 //                     equality + order/range.
 //   - accountId     (EncryptedBigIntOrd → eql_v3_bigint_ord)
@@ -21,10 +21,10 @@
 //                     equality + order/range.
 //   - emailVerified (EncryptedBoolean → eql_v3_boolean)
 //                     STORAGE-ONLY: no search operators at all — every
-//                     cipherstash* predicate throws
+//                     eql* predicate throws
 //                     EncryptionOperatorError on this column.
 //   - preferences   (EncryptedJson → eql_v3_json)
-//                     searchable JSON: cipherstashJsonContains
+//                     searchable JSON: eqlJsonContains
 //                     (encrypted jsonb `@>` containment).
 //
 // v3 emits NO search configs: the domain carries its own index
diff --git a/examples/prisma/src/index.ts b/examples/prisma/src/index.ts
index 0a55bf31..fec356d1 100644
--- a/examples/prisma/src/index.ts
+++ b/examples/prisma/src/index.ts
@@ -20,7 +20,7 @@
  *   - accountId     eql_v3_bigint_ord  — eq + range + ORDER BY
  *   - birthday      eql_v3_date_ord    — eq + range + ORDER BY
  *   - emailVerified eql_v3_boolean     — STORAGE-ONLY (no operators)
- *   - preferences   eql_v3_json        — cipherstashJsonContains (@>)
+ *   - preferences   eql_v3_json        — eqlJsonContains (@>)
  *
  * Prerequisites:
  *
@@ -39,7 +39,6 @@
 import 'dotenv/config'
 
 import {
-  cipherstashV3Asc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
@@ -47,6 +46,7 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
 } from '@cipherstash/prisma-next/runtime'
 
 import { db } from './db'
@@ -117,7 +117,7 @@ async function main() {
     await clearUsers()
     await insertUsers()
     await searchByEq()
-    await searchByIlikeAndDecrypt()
+    await searchByMatchAndDecrypt()
     await rangeQueryOnSalary()
     await betweenQueryOnBirthday()
     await inArrayQueryOnAccountId()
@@ -159,9 +159,9 @@ async function insertUsers(): Promise<void> {
 }
 
 async function searchByEq(): Promise<void> {
-  console.log('\n--- cipherstashEq (text_search equality) ---')
+  console.log('\n--- eqlEq (text_search equality) ---')
   const rows = await db.orm.public.User.where((u) =>
-    u.email.cipherstashEq('alice@example.com'),
+    u.email.eqlEq('alice@example.com'),
   ).all()
   console.log(`Found ${rows.length} row(s) for alice@example.com.`)
   await decryptAll(rows)
@@ -170,13 +170,13 @@ async function searchByEq(): Promise<void> {
   }
 }
 
-async function searchByIlikeAndDecrypt(): Promise<void> {
-  console.log('\n--- cipherstashIlike (text_search free-text tokens) ---')
+async function searchByMatchAndDecrypt(): Promise<void> {
+  console.log('\n--- eqlMatch (text_search free-text tokens) ---')
   // v3 free-text search is bloom-filter TOKEN matching (eql_v3.contains),
   // not SQL ILIKE: the needle's tokens must appear in the ciphertext's
   // index. 'example.com' matches the three @example.com addresses.
   const rows = await db.orm.public.User.where((u) =>
-    u.email.cipherstashIlike('example.com'),
+    u.email.eqlMatch('example.com'),
   ).all()
   console.log(`Found ${rows.length} row(s) whose email contains example.com.`)
   await decryptAll(rows)
@@ -186,9 +186,9 @@ async function searchByIlikeAndDecrypt(): Promise<void> {
 }
 
 async function rangeQueryOnSalary(): Promise<void> {
-  console.log('\n--- cipherstashGt (double_ord order-and-range) ---')
+  console.log('\n--- eqlGt (double_ord order-and-range) ---')
   const rows = await db.orm.public.User.where((u) =>
-    u.salary.cipherstashGt(100_000),
+    u.salary.eqlGt(100_000),
   ).all()
   console.log(`Found ${rows.length} user(s) with salary > 100,000.`)
   await decryptAll(rows)
@@ -198,19 +198,19 @@ async function rangeQueryOnSalary(): Promise<void> {
 }
 
 async function betweenQueryOnBirthday(): Promise<void> {
-  console.log('\n--- cipherstashBetween (date_ord order-and-range) ---')
+  console.log('\n--- eqlBetween (date_ord order-and-range) ---')
   const lower = new Date('1985-01-01')
   const upper = new Date('1995-12-31')
   const rows = await db.orm.public.User.where((u) =>
-    u.birthday.cipherstashBetween(lower, upper),
+    u.birthday.eqlBetween(lower, upper),
   ).all()
   console.log(`Found ${rows.length} user(s) born between 1985 and 1995.`)
 }
 
 async function inArrayQueryOnAccountId(): Promise<void> {
-  console.log('\n--- cipherstashInArray (bigint_ord equality) ---')
+  console.log('\n--- eqlIn (bigint_ord equality) ---')
   const rows = await db.orm.public.User.where((u) =>
-    u.accountId.cipherstashInArray([100_000_000_001n, 100_000_000_004n]),
+    u.accountId.eqlIn([100_000_000_001n, 100_000_000_004n]),
   ).all()
   console.log(
     `Found ${rows.length} user(s) whose accountId is in the supplied array.`,
@@ -224,7 +224,7 @@ async function decryptStorageOnlyBoolean(): Promise<void> {
   // calling one would throw EncryptionOperatorError. Filter on a
   // searchable column and decrypt the boolean from the result set.
   const rows = await db.orm.public.User.where((u) =>
-    u.email.cipherstashEq('carol@example.com'),
+    u.email.eqlEq('carol@example.com'),
   ).all()
   await decryptAll(rows)
   for (const row of rows) {
@@ -235,9 +235,9 @@ async function decryptStorageOnlyBoolean(): Promise<void> {
 }
 
 async function jsonContainmentOnPreferences(): Promise<void> {
-  console.log('\n--- cipherstashJsonContains (encrypted jsonb @>) ---')
+  console.log('\n--- eqlJsonContains (encrypted jsonb @>) ---')
   const rows = await db.orm.public.User.where((u) =>
-    u.preferences.cipherstashJsonContains({ theme: 'dark' }),
+    u.preferences.eqlJsonContains({ theme: 'dark' }),
   ).all()
   console.log(`Found ${rows.length} user(s) with a dark-theme preference.`)
   await decryptAll(rows)
@@ -249,10 +249,8 @@ async function jsonContainmentOnPreferences(): Promise<void> {
 }
 
 async function sortByEmailAsc(): Promise<void> {
-  console.log('\n--- cipherstashV3Asc (encrypted order-term ORDER BY) ---')
-  const rows = await db.orm.public.User.orderBy((u) =>
-    cipherstashV3Asc(u.email),
-  ).all()
+  console.log('\n--- eqlAsc (encrypted order-term ORDER BY) ---')
+  const rows = await db.orm.public.User.orderBy((u) => eqlAsc(u.email)).all()
   await decryptAll(rows)
   for (const row of rows) {
     console.log(`  ${row.id}: email=${await row.email.decrypt()}`)
diff --git a/examples/prisma/src/prisma/contract.d.ts b/examples/prisma/src/prisma/contract.d.ts
index 995e0f8c..01efe328 100644
--- a/examples/prisma/src/prisma/contract.d.ts
+++ b/examples/prisma/src/prisma/contract.d.ts
@@ -10,6 +10,7 @@ import type {
   EncryptedDate,
   EncryptedDouble,
   EncryptedJson,
+  EncryptedNumber,
   EncryptedString,
 } from '@prisma-next/extension-cipherstash/runtime';
 import type {
@@ -493,6 +494,970 @@ type ContractBase = Omit<
                 readonly traits: readonly ['cipherstash:searchable-json'];
               };
             },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_integer@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_integer' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_integer'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_integer_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_integer_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_integer_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_integer_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_integer_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_integer_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_integer_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_integer_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_integer_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_smallint@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_smallint' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_smallint'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_smallint_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_smallint_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_smallint_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_smallint_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_smallint_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_smallint_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_smallint_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_smallint_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_smallint_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_bigint' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_bigint'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_bigint_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_bigint_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_bigint_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_bigint_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_bigint_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_bigint_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_date@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_date' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_date'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_date_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_date_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_date_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_date_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_date_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_date_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_date_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_timestamp@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_timestamp' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_timestamp'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_timestamp_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_timestamp_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_timestamp_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_timestamp_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_timestamp_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_timestamp_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_timestamp_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_timestamp_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_numeric@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_numeric' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_numeric'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_numeric_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_numeric_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_numeric_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_numeric_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_numeric_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_numeric_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_numeric_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_numeric_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_numeric_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text_match@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text_match' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text_match'];
+                readonly traits: readonly ['cipherstash:free-text-search'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_text_search@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_text_search' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_text_search'];
+                readonly traits: readonly [
+                  'cipherstash:equality',
+                  'cipherstash:order-and-range',
+                  'cipherstash:free-text-search',
+                ];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_boolean@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_boolean' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_boolean'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_real@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_real' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_real'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_real_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_real_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_real_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_real_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_real_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_real_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_real_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_real_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_real_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_double@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_double' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_double'];
+                readonly traits: readonly [];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_double_eq@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_double_eq' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_double_eq'];
+                readonly traits: readonly ['cipherstash:equality'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord_ore@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_double_ord_ore' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_double_ord_ore'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_double_ord' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_double_ord'];
+                readonly traits: readonly ['cipherstash:equality', 'cipherstash:order-and-range'];
+              };
+            },
+            {
+              readonly descriptor: {
+                readonly codecId: 'cipherstash/eql-v3/eql_v3_json@1';
+                readonly factory: unknown;
+                readonly isParameterized: true;
+                readonly meta: {
+                  readonly db: {
+                    readonly sql: {
+                      readonly postgres: { readonly nativeType: 'public.eql_v3_json' };
+                    };
+                  };
+                };
+                readonly paramsSchema: {
+                  readonly '~standard': {
+                    readonly validate: unknown;
+                    readonly vendor: 'cipherstash';
+                    readonly version: 1;
+                  };
+                };
+                readonly renderOutputType: unknown;
+                readonly targetTypes: readonly ['public.eql_v3_json'];
+                readonly traits: readonly ['cipherstash:searchable-json'];
+              };
+            },
           ];
           readonly import: {
             readonly alias: 'CipherstashTypes';
@@ -530,6 +1495,11 @@ type ContractBase = Omit<
               readonly named: 'EncryptedJson';
               readonly package: '@prisma-next/extension-cipherstash/runtime';
             },
+            {
+              readonly alias: 'EncryptedNumber';
+              readonly named: 'EncryptedNumber';
+              readonly package: '@prisma-next/extension-cipherstash/runtime';
+            },
           ];
         };
         readonly queryOperationTypes: {
@@ -576,6 +1546,246 @@ type ContractBase = Omit<
             readonly targetId: 'postgres';
             readonly typeId: 'cipherstash/json@1';
           },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_integer';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_integer@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_integer_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_integer_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_integer_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_integer_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_integer_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_integer_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_smallint';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_smallint@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_smallint_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_smallint_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_smallint_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_smallint_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_smallint_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_smallint_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_bigint';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_bigint@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_bigint_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_bigint_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_bigint_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_bigint_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_bigint_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_bigint_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_date';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_date@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_date_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_date_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_date_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_date_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_date_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_date_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_timestamp';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_timestamp@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_timestamp_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_timestamp_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_timestamp_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_timestamp_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_timestamp_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_numeric';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_numeric@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_numeric_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_numeric_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_numeric_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_numeric_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_numeric_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_numeric_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text_match';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text_match@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_text_search';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_text_search@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_boolean';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_boolean@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_real';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_real@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_real_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_real_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_real_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_real_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_real_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_real_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_double';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_double@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_double_eq';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_double_eq@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_double_ord_ore';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_double_ord_ore@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_double_ord';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_double_ord@1';
+          },
+          {
+            readonly familyId: 'sql';
+            readonly nativeType: 'public.eql_v3_json';
+            readonly targetId: 'postgres';
+            readonly typeId: 'cipherstash/eql-v3/eql_v3_json@1';
+          },
         ];
       };
       readonly version: '0.0.1';
diff --git a/examples/prisma/src/prisma/contract.json b/examples/prisma/src/prisma/contract.json
index d49354db..22ebe981 100644
--- a/examples/prisma/src/prisma/contract.json
+++ b/examples/prisma/src/prisma/contract.json
@@ -421,6 +421,1076 @@
                   "cipherstash:searchable-json"
                 ]
               }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_integer@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_integer"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_integer"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_integer_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_integer_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_integer_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_integer_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_integer_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_integer_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_integer_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_integer_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_integer_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_smallint@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_smallint"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_smallint"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_smallint_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_smallint_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_smallint_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_smallint_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_smallint_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_smallint_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_smallint_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_smallint_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_smallint_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_bigint@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_bigint"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_bigint"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_bigint_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_bigint_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_bigint_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_bigint_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_bigint_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_bigint_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_bigint_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_bigint_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_date@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_date"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_date"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_date_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_date_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_date_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_date_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_date_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_date_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_date_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_date_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_date_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_timestamp@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_timestamp"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_timestamp"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_timestamp_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_timestamp_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_timestamp_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_timestamp_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_timestamp_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_timestamp_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_timestamp_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_timestamp_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_numeric@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_numeric"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_numeric"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_numeric_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_numeric_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_numeric_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_numeric_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_numeric_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_numeric_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_numeric_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_numeric_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_numeric_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text_match@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text_match"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text_match"
+                ],
+                "traits": [
+                  "cipherstash:free-text-search"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_text_search@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_text_search"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_text_search"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range",
+                  "cipherstash:free-text-search"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_boolean@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_boolean"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_boolean"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_real@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_real"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_real"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_real_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_real_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_real_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_real_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_real_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_real_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_real_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_real_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_real_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_double@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_double"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_double"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_double_eq@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_double_eq"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_double_eq"
+                ],
+                "traits": [
+                  "cipherstash:equality"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_double_ord_ore@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_double_ord_ore"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_double_ord_ore"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_double_ord@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_double_ord"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_double_ord"
+                ],
+                "traits": [
+                  "cipherstash:equality",
+                  "cipherstash:order-and-range"
+                ]
+              }
+            },
+            {
+              "descriptor": {
+                "codecId": "cipherstash/eql-v3/eql_v3_json@1",
+                "isParameterized": true,
+                "meta": {
+                  "db": {
+                    "sql": {
+                      "postgres": {
+                        "nativeType": "public.eql_v3_json"
+                      }
+                    }
+                  }
+                },
+                "paramsSchema": {
+                  "~standard": {
+                    "vendor": "cipherstash",
+                    "version": 1
+                  }
+                },
+                "targetTypes": [
+                  "public.eql_v3_json"
+                ],
+                "traits": [
+                  "cipherstash:searchable-json"
+                ]
+              }
             }
           ],
           "import": {
@@ -458,6 +1528,11 @@
               "alias": "EncryptedJson",
               "named": "EncryptedJson",
               "package": "@prisma-next/extension-cipherstash/runtime"
+            },
+            {
+              "alias": "EncryptedNumber",
+              "named": "EncryptedNumber",
+              "package": "@prisma-next/extension-cipherstash/runtime"
             }
           ]
         },
@@ -504,6 +1579,246 @@
             "nativeType": "eql_v2_encrypted",
             "targetId": "postgres",
             "typeId": "cipherstash/json@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_integer",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_integer@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_integer_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_integer_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_integer_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_integer_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_integer_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_integer_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_smallint",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_smallint@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_smallint_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_smallint_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_smallint_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_smallint_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_smallint_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_smallint_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_bigint",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_bigint@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_bigint_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_bigint_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_bigint_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_bigint_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_bigint_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_bigint_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_date",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_date@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_date_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_date_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_date_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_date_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_date_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_date_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_timestamp",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_timestamp@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_timestamp_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_timestamp_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_timestamp_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_timestamp_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_timestamp_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_numeric",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_numeric@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_numeric_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_numeric_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_numeric_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_numeric_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_numeric_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_numeric_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text_match",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text_match@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_text_search",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_text_search@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_boolean",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_boolean@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_real",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_real@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_real_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_real_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_real_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_real_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_real_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_real_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_double",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_double@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_double_eq",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_double_eq@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_double_ord_ore",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_double_ord_ore@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_double_ord",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_double_ord@1"
+          },
+          {
+            "familyId": "sql",
+            "nativeType": "public.eql_v3_json",
+            "targetId": "postgres",
+            "typeId": "cipherstash/eql-v3/eql_v3_json@1"
           }
         ]
       },
diff --git a/examples/prisma/test/e2e/README.md b/examples/prisma/test/e2e/README.md
index 9520ca98..7750758a 100644
--- a/examples/prisma/test/e2e/README.md
+++ b/examples/prisma/test/e2e/README.md
@@ -2,12 +2,12 @@
 
 This directory hosts the live-Postgres + EQL v3 bundle + ZeroKMS end-to-end harness for the @cipherstash/prisma-next example app. Seven `*.e2e.test.ts` files cover one domain or scenario each:
 
-- `num.e2e.test.ts` — `eql_v3_double_ord` round-trip (decrypts to `EncryptedNumber`); `Gt`/`Gte`/`Lt`/`Lte`/`Between`; `cipherstashV3Asc`/`Desc` order-term sort.
+- `num.e2e.test.ts` — `eql_v3_double_ord` round-trip (decrypts to `EncryptedNumber`); `eqlGt`/`eqlGte`/`eqlLt`/`eqlLte`/`eqlBetween`; `eqlAsc`/`eqlDesc` order-term sort.
 - `bigint.e2e.test.ts` — `eql_v3_bigint_ord` round-trip **lossless beyond `Number.MAX_SAFE_INTEGER`** (native `bigint` pipeline); equality + range + in-array + sort.
 - `date.e2e.test.ts` — `eql_v3_date_ord` round-trip; date range + order-term sort.
 - `bool.e2e.test.ts` — `eql_v3_boolean` is STORAGE-ONLY: round-trip works, the ORM binds no operator methods to the column, and the operator impls throw `EncryptionOperatorError` against it.
-- `json.e2e.test.ts` — `eql_v3_json` round-trip + `cipherstashJsonContains` (encrypted jsonb `@>`): top-level, multi-key, array-element, and nested containment, negative cases, and the loud rejection of the match-everything `{}` needle.
-- `str-range.e2e.test.ts` — `eql_v3_text_search` carries equality + order/range + free-text on one column: `Eq`, `Gt`, `V3Asc`/`V3Desc`, and `Ilike` (bloom-filter token containment — not SQL `ILIKE`) coexist.
+- `json.e2e.test.ts` — `eql_v3_json` round-trip + `eqlJsonContains` (encrypted jsonb `@>`): top-level, multi-key, array-element, and nested containment, negative cases, and the loud rejection of the match-everything `{}` needle.
+- `str-range.e2e.test.ts` — `eql_v3_text_search` carries equality + order/range + free-text on one column: `eqlEq`, `eqlGt`, `eqlAsc`/`eqlDesc`, and `eqlMatch` (fuzzy bloom-filter token matching — not SQL `ILIKE`) coexist.
 - `mixed.e2e.test.ts` — mixed-domain query issues the minimum framework-SDK crossings (one `bulkEncrypt` seam call per `(table, column)`; operands become ciphertext-free `encryptQuery` terms inside the v3 adapter).
 
 ## Local setup
@@ -34,7 +34,7 @@ The `docker-compose.yml` runs `postgres:16-alpine` on host port `54329` (non-sta
 
 The v2 iteration of this harness carried two known-limitation carve-outs; both are gone on v3:
 
-- **JSON predicates work.** v2's `cipherstashJsonbPathExists` needed client-side STE-VEC selector hashing and was skipped. v3's containment model (`cipherstashJsonContains` → `@>` with an `eql_v3.query_jsonb` term) runs end-to-end — no skips in `json.e2e.test.ts`.
+- **JSON predicates work.** v2's `cipherstashJsonbPathExists` needed client-side STE-VEC selector hashing and was skipped. v3's containment model (`eqlJsonContains` → `@>` with an `eql_v3.query_jsonb` term) runs end-to-end — no skips in `json.e2e.test.ts`.
 - **BigInt is lossless.** v2 converted `bigint → Number` at the SDK boundary and capped values at `Number.MAX_SAFE_INTEGER`. v3's protect-ffi wire is natively `bigint` (bounds-checked int8), and `bigint.e2e.test.ts` pins a 2^53 + 1 round-trip.
 
 One new-in-v3 refusal is deliberately pinned rather than worked around: `eql_v3_boolean` is storage-only, so `bool.e2e.test.ts` asserts the operator surface is absent/throwing instead of querying it.
diff --git a/examples/prisma/test/e2e/bigint.e2e.test.ts b/examples/prisma/test/e2e/bigint.e2e.test.ts
index a4d986ca..602b974d 100644
--- a/examples/prisma/test/e2e/bigint.e2e.test.ts
+++ b/examples/prisma/test/e2e/bigint.e2e.test.ts
@@ -12,7 +12,6 @@
  */
 
 import {
-  cipherstashV3Asc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
@@ -20,6 +19,7 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -68,16 +68,16 @@ describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     }
   })
 
-  it('cipherstashEq selects exactly the row holding the unsafe-range value', async () => {
+  it('eqlEq selects exactly the row holding the unsafe-range value', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashEq(UNSAFE_BIG),
+      u.accountId.eqlEq(UNSAFE_BIG),
     ).all()
     expect(rows.map((r) => r.id)).toEqual(['e2e-bigint-3'])
   })
 
-  it('cipherstashGt filters by encrypted bigint numeric order', async () => {
+  it('eqlGt filters by encrypted bigint numeric order', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashGt(1_000_000_000_002n),
+      u.accountId.eqlGt(1_000_000_000_002n),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-bigint-2',
@@ -85,9 +85,9 @@ describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashLte includes the equality boundary', async () => {
+  it('eqlLte includes the equality boundary', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashLte(1_000_000_000_002n),
+      u.accountId.eqlLte(1_000_000_000_002n),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-bigint-0',
@@ -95,12 +95,9 @@ describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashBetween filters by encrypted bigint range', async () => {
+  it('eqlBetween filters by encrypted bigint range', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashBetween(
-        1_000_000_000_002n,
-        9_000_000_000_000_000n,
-      ),
+      u.accountId.eqlBetween(1_000_000_000_002n, 9_000_000_000_000_000n),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-bigint-1',
@@ -108,9 +105,9 @@ describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashInArray returns rows whose value matches any of the supplied bigints', async () => {
+  it('eqlIn returns rows whose value matches any of the supplied bigints', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.accountId.cipherstashInArray([1_000_000_000_001n, UNSAFE_BIG]),
+      u.accountId.eqlIn([1_000_000_000_001n, UNSAFE_BIG]),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-bigint-0',
@@ -118,12 +115,12 @@ describe('EncryptedBigInt (eql_v3_bigint_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashV3Asc orders by bigint value via the encrypted order term', async () => {
+  it('eqlAsc orders by bigint value via the encrypted order term', async () => {
     // 2^53 + 1 = 9_007_199_254_740_993 > 9_000_000_000_000_000, so the
     // unsafe-range row sorts LAST — on the true int8 value, not a lossy
     // float projection.
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Asc(u.accountId),
+      eqlAsc(u.accountId),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-bigint-0',
diff --git a/examples/prisma/test/e2e/bool.e2e.test.ts b/examples/prisma/test/e2e/bool.e2e.test.ts
index c91ad530..f565458c 100644
--- a/examples/prisma/test/e2e/bool.e2e.test.ts
+++ b/examples/prisma/test/e2e/bool.e2e.test.ts
@@ -8,7 +8,7 @@
  *   - INSERT + decrypt round-trip recovers `true` / `false`.
  *   - The ORM accessor binds NO cipherstash operator methods to the
  *     column (runtime trait dispatch: the codec has no traits, so
- *     `u.emailVerified.cipherstashEq` is `undefined`).
+ *     `u.emailVerified.eqlEq` is `undefined`).
  *   - Calling the operator impls directly against the column throws
  *     `EncryptionOperatorError` (the per-domain capability gate).
  *
@@ -77,26 +77,25 @@ describe('eql_v3_boolean storage-only e2e (live PG + EQL v3 + ZeroKMS)', () => {
     // cipherstash traits, so the model accessor never attaches the
     // operator methods. Every method the other suites use must be
     // absent here. (Type-level visibility agrees: none of these
-    // compile on `u.emailVerified`, hence the untyped probe.)
+    // compile on `u.emailVerified` — `Reflect.get` probes the runtime
+    // object without asserting a widened column type.)
     const observed: Record<string, string> = {}
     await db.orm.public.User.where((u) => {
-      const probe = u.emailVerified as unknown as Record<string, unknown>
       for (const method of [
-        'cipherstashEq',
-        'cipherstashNe',
-        'cipherstashInArray',
-        'cipherstashNotInArray',
-        'cipherstashGt',
-        'cipherstashGte',
-        'cipherstashLt',
-        'cipherstashLte',
-        'cipherstashBetween',
-        'cipherstashNotBetween',
-        'cipherstashIlike',
-        'cipherstashNotIlike',
-        'cipherstashJsonContains',
+        'eqlEq',
+        'eqlNeq',
+        'eqlIn',
+        'eqlNotIn',
+        'eqlGt',
+        'eqlGte',
+        'eqlLt',
+        'eqlLte',
+        'eqlBetween',
+        'eqlNotBetween',
+        'eqlMatch',
+        'eqlJsonContains',
       ]) {
-        observed[method] = typeof probe[method]
+        observed[method] = typeof Reflect.get(u.emailVerified, method)
       }
       return u.id.isNotNull()
     }).all()
@@ -112,26 +111,32 @@ describe('eql_v3_boolean storage-only e2e (live PG + EQL v3 + ZeroKMS)', () => {
     // Reach the impls the way a custom builder could: with the column
     // expression captured from the typed SQL surface. The per-domain
     // capability gate must refuse the storage-only domain loudly.
+    //
+    // The registry declares `impl` with bottom-typed rest parameters
+    // (`(...args: never[]) => ...`) so descriptors of every arity stay
+    // assignable; calling one from a test needs a caller-shaped
+    // signature. This widening names the runtime boundary precisely
+    // (self + operand list; the return is unused and the gate throws
+    // before one is produced) instead of erasing arguments to `never`.
+    type CallableOperatorImpl = (self: unknown, ...args: unknown[]) => never
     const attempts: ReadonlyArray<readonly [string, readonly unknown[]]> = [
-      ['cipherstashEq', [true]],
-      ['cipherstashNe', [false]],
-      ['cipherstashInArray', [[true, false]]],
-      ['cipherstashNotInArray', [[true]]],
-      ['cipherstashGt', [false]],
-      ['cipherstashBetween', [false, true]],
-      ['cipherstashIlike', ['tru']],
-      ['cipherstashJsonContains', [{ verified: true }]],
+      ['eqlEq', [true]],
+      ['eqlNeq', [false]],
+      ['eqlIn', [[true, false]]],
+      ['eqlNotIn', [[true]]],
+      ['eqlGt', [false]],
+      ['eqlBetween', [false, true]],
+      ['eqlMatch', ['tru']],
+      ['eqlJsonContains', [{ verified: true }]],
     ]
     db.sql.public.users
       .select((f) => {
         for (const [method, args] of attempts) {
           const op = ops[method]
           expect(op, `operator ${method} registered`).toBeDefined()
+          const impl = op?.impl as CallableOperatorImpl | undefined
           expect(
-            // The select-scope field is the same column-bound expression
-            // the where-scope hands to operator impls; the impl parameter
-            // type is wider than the scope field type, hence the cast.
-            () => op?.impl(f.emailverified as never, ...(args as never[])),
+            () => impl?.(f.emailverified, ...args),
             `${method} must refuse eql_v3_boolean`,
           ).toThrow(EncryptionOperatorError)
         }
diff --git a/examples/prisma/test/e2e/date.e2e.test.ts b/examples/prisma/test/e2e/date.e2e.test.ts
index 005d8c36..c1146cd0 100644
--- a/examples/prisma/test/e2e/date.e2e.test.ts
+++ b/examples/prisma/test/e2e/date.e2e.test.ts
@@ -4,9 +4,9 @@
  *
  * Pins:
  *   - INSERT + decrypt round-trip recovers the source `Date`.
- *   - `cipherstashGt(<date>)` returns rows whose date is later.
- *   - `cipherstashBetween` filters a closed interval.
- *   - `cipherstashV3Asc` / `cipherstashV3Desc` order by calendar date
+ *   - `eqlGt(<date>)` returns rows whose date is later.
+ *   - `eqlBetween` filters a closed interval.
+ *   - `eqlAsc` / `eqlDesc` order by calendar date
  *     via the encrypted order term (`eql_v3.ord_term(col)`).
  *
  * protect-ffi's eqlVersion-3 wire accepts `Date` plaintexts natively
@@ -14,8 +14,6 @@
  */
 
 import {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
@@ -23,6 +21,8 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
+  eqlDesc,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -71,26 +71,23 @@ describe('EncryptedDate (eql_v3_date_ord) e2e (live PG + EQL v3 + ZeroKMS)', ()
     }
   })
 
-  it('cipherstashGt filters dates after the cutoff', async () => {
+  it('eqlGt filters dates after the cutoff', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.birthday.cipherstashGt(new Date('1995-01-01')),
+      u.birthday.eqlGt(new Date('1995-01-01')),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-date-2', 'e2e-date-3'])
   })
 
-  it('cipherstashBetween filters a closed date interval', async () => {
+  it('eqlBetween filters a closed date interval', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.birthday.cipherstashBetween(
-        new Date('1985-01-01'),
-        new Date('2005-12-31'),
-      ),
+      u.birthday.eqlBetween(new Date('1985-01-01'), new Date('2005-12-31')),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-date-1', 'e2e-date-2'])
   })
 
-  it('cipherstashV3Asc orders by calendar date via the encrypted order term', async () => {
+  it('eqlAsc orders by calendar date via the encrypted order term', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Asc(u.birthday),
+      eqlAsc(u.birthday),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-date-0',
@@ -100,9 +97,9 @@ describe('EncryptedDate (eql_v3_date_ord) e2e (live PG + EQL v3 + ZeroKMS)', ()
     ])
   })
 
-  it('cipherstashV3Desc reverses the date order', async () => {
+  it('eqlDesc reverses the date order', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Desc(u.birthday),
+      eqlDesc(u.birthday),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-date-3',
diff --git a/examples/prisma/test/e2e/json.e2e.test.ts b/examples/prisma/test/e2e/json.e2e.test.ts
index d618b4a8..858d3bd0 100644
--- a/examples/prisma/test/e2e/json.e2e.test.ts
+++ b/examples/prisma/test/e2e/json.e2e.test.ts
@@ -3,7 +3,7 @@
  * Postgres + EQL v3 + ZeroKMS.
  *
  * v3 searchable JSON is containment-only: the ste_vec index answers
- * encrypted jsonb `@>` via `cipherstashJsonContains`, with the operand
+ * encrypted jsonb `@>` via `eqlJsonContains`, with the operand
  * minted as a ciphertext-free `eql_v3.query_jsonb` term. The v2
  * `cipherstashJsonbPathQueryFirst` / `cipherstashJsonbGet` /
  * `cipherstashJsonbPathExists` helpers do not exist in v3 (and with
@@ -12,7 +12,7 @@
  *
  * Pins:
  *   - INSERT + decrypt round-trip recovers the source JSON object.
- *   - `cipherstashJsonContains` selects by top-level, multi-key,
+ *   - `eqlJsonContains` selects by top-level, multi-key,
  *     nested-array, and nested-object containment (exact jsonb `@>`
  *     semantics, no false positives).
  *   - Negative cases: non-matching needles select zero rows.
@@ -93,16 +93,16 @@ describe('EncryptedJson (eql_v3_json) e2e (live PG + EQL v3 + ZeroKMS)', () => {
     }
   })
 
-  it('cipherstashJsonContains selects by top-level key/value containment', async () => {
+  it('eqlJsonContains selects by top-level key/value containment', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({ theme: 'dark' }),
+      u.preferences.eqlJsonContains({ theme: 'dark' }),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-json-0', 'e2e-json-2'])
   })
 
-  it('cipherstashJsonContains requires ALL needle keys (multi-key containment)', async () => {
+  it('eqlJsonContains requires ALL needle keys (multi-key containment)', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({
+      u.preferences.eqlJsonContains({
         theme: 'dark',
         locale: 'en-US',
       }),
@@ -110,34 +110,34 @@ describe('EncryptedJson (eql_v3_json) e2e (live PG + EQL v3 + ZeroKMS)', () => {
     expect(rows.map((r) => r.id)).toEqual(['e2e-json-0'])
   })
 
-  it('cipherstashJsonContains matches array-element containment', async () => {
+  it('eqlJsonContains matches array-element containment', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({ tags: ['beta'] }),
+      u.preferences.eqlJsonContains({ tags: ['beta'] }),
     ).all()
     // jsonb `@>`: ['alpha','beta'] ⊇ ['beta'] and ['beta'] ⊇ ['beta'].
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-json-0', 'e2e-json-1'])
   })
 
-  it('cipherstashJsonContains matches nested-object containment', async () => {
+  it('eqlJsonContains matches nested-object containment', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({ nested: { admin: true } }),
+      u.preferences.eqlJsonContains({ nested: { admin: true } }),
     ).all()
     expect(rows.map((r) => r.id)).toEqual(['e2e-json-2'])
   })
 
-  it('cipherstashJsonContains returns zero rows for non-matching needles', async () => {
+  it('eqlJsonContains returns zero rows for non-matching needles', async () => {
     const wrongValue = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({ theme: 'sepia' }),
+      u.preferences.eqlJsonContains({ theme: 'sepia' }),
     ).all()
     expect(wrongValue).toHaveLength(0)
 
     const wrongKey = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({ timezone: 'UTC' }),
+      u.preferences.eqlJsonContains({ timezone: 'UTC' }),
     ).all()
     expect(wrongKey).toHaveLength(0)
 
     const partialNested = await db.orm.public.User.where((u) =>
-      u.preferences.cipherstashJsonContains({
+      u.preferences.eqlJsonContains({
         nested: { level: 3, admin: false },
       }),
     ).all()
@@ -146,9 +146,7 @@ describe('EncryptedJson (eql_v3_json) e2e (live PG + EQL v3 + ZeroKMS)', () => {
 
   it('rejects the match-everything empty-object needle loudly', () => {
     expect(() =>
-      db.orm.public.User.where((u) =>
-        u.preferences.cipherstashJsonContains({}),
-      ),
+      db.orm.public.User.where((u) => u.preferences.eqlJsonContains({})),
     ).toThrow(EncryptionOperatorError)
   })
 })
diff --git a/examples/prisma/test/e2e/mixed.e2e.test.ts b/examples/prisma/test/e2e/mixed.e2e.test.ts
index 86252580..95776d32 100644
--- a/examples/prisma/test/e2e/mixed.e2e.test.ts
+++ b/examples/prisma/test/e2e/mixed.e2e.test.ts
@@ -29,7 +29,6 @@
 
 import {
   bulkEncryptMiddlewareV3,
-  cipherstashV3Asc,
   createCipherstashV3RuntimeDescriptor,
   decryptAll,
   EncryptedBigInt,
@@ -38,6 +37,7 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
 } from '@cipherstash/prisma-next/runtime'
 import {
   cipherstashFromStackV3,
@@ -170,12 +170,12 @@ describe('Mixed-domain e2e (live PG + EQL v3 + ZeroKMS)', () => {
   it('executes a three-column WHERE + order-term read end-to-end', async () => {
     const rows = await db.orm.public.User.where((u) =>
       and(
-        u.email.cipherstashIlike('example.com'),
-        u.salary.cipherstashGt(75_000),
-        u.birthday.cipherstashLt(new Date('2000-01-01')),
+        u.email.eqlMatch('example.com'),
+        u.salary.eqlGt(75_000),
+        u.birthday.eqlLt(new Date('2000-01-01')),
       ),
     )
-      .orderBy((u) => cipherstashV3Asc(u.salary))
+      .orderBy((u) => eqlAsc(u.salary))
       .all()
 
     // carol (90k) and bob (110k) survive all three predicates, ordered
@@ -189,12 +189,12 @@ describe('Mixed-domain e2e (live PG + EQL v3 + ZeroKMS)', () => {
     counting.counts.reset()
     await db.orm.public.User.where((u) =>
       and(
-        u.email.cipherstashIlike('example.com'),
-        u.salary.cipherstashGt(75_000),
-        u.birthday.cipherstashLt(new Date('2000-01-01')),
+        u.email.eqlMatch('example.com'),
+        u.salary.eqlGt(75_000),
+        u.birthday.eqlLt(new Date('2000-01-01')),
       ),
     )
-      .orderBy((u) => cipherstashV3Asc(u.salary))
+      .orderBy((u) => eqlAsc(u.salary))
       .all()
     // Three distinct (users, <column>) groups in the WHERE — one
     // framework-SDK `bulkEncrypt` crossing per group (each routed to
diff --git a/examples/prisma/test/e2e/num.e2e.test.ts b/examples/prisma/test/e2e/num.e2e.test.ts
index 4a5366e2..8bb41bc4 100644
--- a/examples/prisma/test/e2e/num.e2e.test.ts
+++ b/examples/prisma/test/e2e/num.e2e.test.ts
@@ -6,11 +6,11 @@
  *   - INSERT + decrypt round-trip recovers the source numbers (v3
  *     `number`-castAs domains decrypt to the `EncryptedNumber`
  *     envelope, not the v2 `EncryptedDouble`).
- *   - `cipherstashGt`, `cipherstashGte`, `cipherstashLt`,
- *     `cipherstashLte`, `cipherstashBetween` each filter rows
+ *   - `eqlGt`, `eqlGte`, `eqlLt`,
+ *     `eqlLte`, `eqlBetween` each filter rows
  *     correctly against the OPE-indexed encrypted column
  *     (`eql_v3.gt(col, $n::eql_v3.query_double_ord)` and friends).
- *   - `cipherstashV3Asc` / `cipherstashV3Desc` produce numerically
+ *   - `eqlAsc` / `eqlDesc` produce numerically
  *     sorted results. Unlike v2's bare-column ORDER BY, v3 sorting
  *     extracts the encrypted order term (`eql_v3.ord_term(col)`) —
  *     the domain has no cross-row comparison operators of its own.
@@ -21,8 +21,6 @@
  */
 
 import {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
@@ -30,6 +28,8 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
+  eqlDesc,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -72,16 +72,16 @@ describe('EncryptedNumber (eql_v3_double_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     }
   })
 
-  it('cipherstashGt filters by encrypted numeric order', async () => {
+  it('eqlGt filters by encrypted numeric order', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.salary.cipherstashGt(95_000),
+      u.salary.eqlGt(95_000),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-num-2', 'e2e-num-3'])
   })
 
-  it('cipherstashGte includes the equality boundary', async () => {
+  it('eqlGte includes the equality boundary', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.salary.cipherstashGte(95_000),
+      u.salary.eqlGte(95_000),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-num-1',
@@ -90,16 +90,16 @@ describe('EncryptedNumber (eql_v3_double_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashLt filters strict-less-than', async () => {
+  it('eqlLt filters strict-less-than', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.salary.cipherstashLt(120_000),
+      u.salary.eqlLt(120_000),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-num-0', 'e2e-num-1'])
   })
 
-  it('cipherstashLte includes the equality boundary', async () => {
+  it('eqlLte includes the equality boundary', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.salary.cipherstashLte(120_000),
+      u.salary.eqlLte(120_000),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-num-0',
@@ -108,17 +108,15 @@ describe('EncryptedNumber (eql_v3_double_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashBetween bounds inclusively on both sides', async () => {
+  it('eqlBetween bounds inclusively on both sides', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.salary.cipherstashBetween(95_000, 120_000),
+      u.salary.eqlBetween(95_000, 120_000),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-num-1', 'e2e-num-2'])
   })
 
-  it('cipherstashV3Asc orders by numeric value via the encrypted order term', async () => {
-    const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Asc(u.salary),
-    ).all()
+  it('eqlAsc orders by numeric value via the encrypted order term', async () => {
+    const rows = await db.orm.public.User.orderBy((u) => eqlAsc(u.salary)).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-num-0',
       'e2e-num-1',
@@ -127,9 +125,9 @@ describe('EncryptedNumber (eql_v3_double_ord) e2e (live PG + EQL v3 + ZeroKMS)',
     ])
   })
 
-  it('cipherstashV3Desc reverses the ascending order', async () => {
+  it('eqlDesc reverses the ascending order', async () => {
     const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Desc(u.salary),
+      eqlDesc(u.salary),
     ).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-num-3',
diff --git a/examples/prisma/test/e2e/str-range.e2e.test.ts b/examples/prisma/test/e2e/str-range.e2e.test.ts
index 3a60152d..4c4703ec 100644
--- a/examples/prisma/test/e2e/str-range.e2e.test.ts
+++ b/examples/prisma/test/e2e/str-range.e2e.test.ts
@@ -6,18 +6,18 @@
  * equality + order/range (OPE) + free-text search (bloom match) on one
  * column. Pins:
  *   - Round-trip decrypt recovers the source strings.
- *   - `cipherstashEq` selects exactly the matching row.
- *   - `cipherstashGt('m')` filters lexicographically.
- *   - `cipherstashV3Asc` / `cipherstashV3Desc` order alphabetically
+ *   - `eqlEq` selects exactly the matching row.
+ *   - `eqlGt('m')` filters lexicographically.
+ *   - `eqlAsc` / `eqlDesc` order alphabetically
  *     via the encrypted order term.
- *   - `cipherstashIlike` — bloom-filter TOKEN containment
+ *   - `eqlMatch` — bloom-filter TOKEN containment
  *     (`eql_v3.contains`), not SQL ILIKE — coexists with the
  *     order-and-range operators on the same column.
  */
 
+import 'dotenv/config'
+
 import {
-  cipherstashV3Asc,
-  cipherstashV3Desc,
   decryptAll,
   EncryptedBigInt,
   EncryptedBoolean,
@@ -25,6 +25,8 @@ import {
   EncryptedJson,
   EncryptedNumber,
   EncryptedString,
+  eqlAsc,
+  eqlDesc,
 } from '@cipherstash/prisma-next/runtime'
 import { beforeAll, describe, expect, it } from 'vitest'
 import { db, ensureConnected, truncateUsers } from './harness'
@@ -67,24 +69,20 @@ describe('EncryptedString (eql_v3_text_search) e2e (live PG + EQL v3 + ZeroKMS)'
     }
   })
 
-  it('cipherstashEq selects exactly the matching row', async () => {
+  it('eqlEq selects exactly the matching row', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.email.cipherstashEq('mallory@example.com'),
+      u.email.eqlEq('mallory@example.com'),
     ).all()
     expect(rows.map((r) => r.id)).toEqual(['e2e-str-2'])
   })
 
-  it('cipherstashGt filters lexicographically', async () => {
-    const rows = await db.orm.public.User.where((u) =>
-      u.email.cipherstashGt('m'),
-    ).all()
+  it('eqlGt filters lexicographically', async () => {
+    const rows = await db.orm.public.User.where((u) => u.email.eqlGt('m')).all()
     expect(rows.map((r) => r.id).sort()).toEqual(['e2e-str-2', 'e2e-str-3'])
   })
 
-  it('cipherstashV3Asc orders alphabetically via the encrypted order term', async () => {
-    const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Asc(u.email),
-    ).all()
+  it('eqlAsc orders alphabetically via the encrypted order term', async () => {
+    const rows = await db.orm.public.User.orderBy((u) => eqlAsc(u.email)).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-str-0',
       'e2e-str-1',
@@ -93,10 +91,8 @@ describe('EncryptedString (eql_v3_text_search) e2e (live PG + EQL v3 + ZeroKMS)'
     ])
   })
 
-  it('cipherstashV3Desc reverses the alphabetical order', async () => {
-    const rows = await db.orm.public.User.orderBy((u) =>
-      cipherstashV3Desc(u.email),
-    ).all()
+  it('eqlDesc reverses the alphabetical order', async () => {
+    const rows = await db.orm.public.User.orderBy((u) => eqlDesc(u.email)).all()
     expect(rows.map((r) => r.id)).toEqual([
       'e2e-str-3',
       'e2e-str-2',
@@ -105,9 +101,9 @@ describe('EncryptedString (eql_v3_text_search) e2e (live PG + EQL v3 + ZeroKMS)'
     ])
   })
 
-  it('cipherstashIlike (bloom token containment) coexists with order-and-range', async () => {
+  it('eqlMatch (bloom token containment) coexists with order-and-range', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.email.cipherstashIlike('example.com'),
+      u.email.eqlMatch('example.com'),
     ).all()
     expect(rows.map((r) => r.id).sort()).toEqual([
       'e2e-str-0',
@@ -116,9 +112,9 @@ describe('EncryptedString (eql_v3_text_search) e2e (live PG + EQL v3 + ZeroKMS)'
     ])
   })
 
-  it('cipherstashIlike misses tokens absent from the ciphertext index', async () => {
+  it('eqlMatch misses tokens absent from the ciphertext index', async () => {
     const rows = await db.orm.public.User.where((u) =>
-      u.email.cipherstashIlike('nonexistent-token'),
+      u.email.eqlMatch('nonexistent-token'),
     ).all()
     expect(rows).toHaveLength(0)
   })

From 06df3474dbe7c2c6196e9bae654a9449f3eaeefb Mon Sep 17 00:00:00 2001
From: CJ Brewer <cj@cipherstash.com>
Date: Thu, 16 Jul 2026 16:58:52 -0600
Subject: [PATCH 18/21] test(prisma-next): test-kit family integration suite +
 CI job
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implement makePrismaNextAdapter() behind the shared
@cipherstash/test-kit IntegrationAdapter seam and run runFamilySuite
over every family — the same derived capability matrix, plaintext
oracle, single-vs-bulk insert crossover, ordering assertions, and
absent/null handling that pin the Drizzle and Supabase adapters (PR
#655 review, item 4). Queries lower through the real v3 operator
registry + postgres adapter + bulk-encrypt middleware; inserts run
one-row vs multi-row INSERT statements, prisma-next's two batching
shapes. New CI workflow mirrors the Drizzle job on both database
variants. 582 tests green against real ZeroKMS + live Postgres.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/integration-prisma-next.yml | 129 ++++++++
 packages/prisma-next/integration/adapter.ts   | 310 ++++++++++++++++++
 .../integration/families.integration.test.ts  |  12 +
 .../prisma-next/integration/vitest.config.ts  |  22 ++
 packages/prisma-next/tsconfig.json            |  20 +-
 packages/test-kit/src/adapter.ts              |   2 +-
 6 files changed, 492 insertions(+), 3 deletions(-)
 create mode 100644 .github/workflows/integration-prisma-next.yml
 create mode 100644 packages/prisma-next/integration/adapter.ts
 create mode 100644 packages/prisma-next/integration/families.integration.test.ts
 create mode 100644 packages/prisma-next/integration/vitest.config.ts

diff --git a/.github/workflows/integration-prisma-next.yml b/.github/workflows/integration-prisma-next.yml
new file mode 100644
index 00000000..55eb9585
--- /dev/null
+++ b/.github/workflows/integration-prisma-next.yml
@@ -0,0 +1,129 @@
+name: Integration — prisma-next (EQL v3)
+
+# Real ZeroKMS ciphertext against a real Postgres, on BOTH database variants —
+# the prisma-next leg of the shared test-kit family driver (the same catalog,
+# oracle, and single-vs-bulk crossover as the Drizzle and Supabase jobs).
+#
+# The prisma-next adapter talks straight to the database, so it does not need
+# PostgREST — but it does need to work on managed Postgres, where the `postgres`
+# role is not a superuser, the EQL install takes its self-skipping path, and the
+# ORE domains cannot hold data. The Supabase compose file brings up PostgREST
+# too; this job simply ignores it.
+#
+# Separate from `tests.yml` on purpose: these suites need CipherStash credentials
+# and a database, and they THROW rather than skip when unconfigured. Keeping them
+# out of the unit job is what lets `pnpm test` stay runnable with neither.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'packages/stack/src/eql/v3/**'
+      - 'packages/prisma-next/**'
+      # Source layers the adapter's encoding/round-trip rests on: a break here
+      # (not just under src/eql/v3) can produce wrong rows, so trigger the live
+      # suite that would catch it.
+      - 'packages/stack/src/encryption/**'
+      - 'packages/stack/src/schema/**'
+      - 'packages/schema/**'
+      - 'packages/test-kit/**'
+      - 'packages/cli/src/installer/**'
+      - 'local/docker-compose.postgres.yml'
+      - 'local/docker-compose.supabase.yml'
+      - 'local/supabase-init.sql'
+      - '.github/workflows/integration-prisma-next.yml'
+      - '.github/actions/integration-setup/**'
+  pull_request:
+    branches: ['**']
+    # Repeated verbatim: GitHub Actions does not support YAML anchors/aliases.
+    paths:
+      - 'packages/stack/src/eql/v3/**'
+      - 'packages/prisma-next/**'
+      # Source layers the adapter's encoding/round-trip rests on: a break here
+      # (not just under src/eql/v3) can produce wrong rows, so trigger the live
+      # suite that would catch it.
+      - 'packages/stack/src/encryption/**'
+      - 'packages/stack/src/schema/**'
+      - 'packages/schema/**'
+      - 'packages/test-kit/**'
+      - 'packages/cli/src/installer/**'
+      - 'local/docker-compose.postgres.yml'
+      - 'local/docker-compose.supabase.yml'
+      - 'local/supabase-init.sql'
+      - '.github/workflows/integration-prisma-next.yml'
+      - '.github/actions/integration-setup/**'
+
+jobs:
+  integration:
+    name: prisma-next v3 integration (db=${{ matrix.db }})
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    # Serialize every job that brings up the SAME docker-compose stack — same
+    # rationale and keys as the Drizzle/Supabase workflows, so the jobs queue
+    # on a shared runner rather than collide on the fixed host ports.
+    concurrency:
+      group: integration-live-db-${{ matrix.db }}
+      cancel-in-progress: false
+    # Fork PRs have no secrets. Skip cleanly rather than fail on something the
+    # contributor cannot fix — `tests.yml` still gives them a green signal.
+    if: ${{ github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository }}
+
+    strategy:
+      fail-fast: false
+      # prisma-next talks straight to Postgres, so it runs against BOTH
+      # databases. The Supabase variant is not a formality: its `postgres` role
+      # is not a superuser, so the EQL install takes its self-skipping path. A
+      # suite that passes on a superuser database can still fail there.
+      matrix:
+        include:
+          - db: postgres
+            database-url: postgres://cipherstash:password@localhost:55432/cipherstash
+            pgrest-url: ''
+          - db: supabase
+            database-url: postgres://postgres:password@localhost:55433/postgres
+            pgrest-url: http://localhost:55430
+
+    env:
+      CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }}
+      CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }}
+      CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }}
+      CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }}
+      # Job-level env, not a `.env` file: `dotenv/config` does not override an
+      # already-set `process.env`, so these win and no secret is written to disk.
+      DATABASE_URL: ${{ matrix.database-url }}
+      PGRST_URL: ${{ matrix.pgrest-url }}
+      # EXPLICIT, never inferred — same rationale as the Drizzle workflow.
+      CS_IT_DB_VARIANT: ${{ matrix.db }}
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ./.github/actions/integration-setup
+
+      # Fast pre-flight: fail in seconds if a secret was rotated or cleared,
+      # before the docker pull. The in-test `requireIntegrationEnv` is the
+      # correctness guarantee; this is the cheap one.
+      - name: Require CipherStash secrets
+        uses: ./.github/actions/require-cs-secrets
+        with:
+          workspace-crn: ${{ vars.CS_WORKSPACE_CRN }}
+          client-id: ${{ vars.CS_CLIENT_ID }}
+          client-key: ${{ secrets.CS_CLIENT_KEY }}
+          client-access-key: ${{ secrets.CS_CLIENT_ACCESS_KEY }}
+
+      # Belt-and-braces for the concurrency guard: a run that was hard-killed
+      # can skip its `down` and leak a container holding the host port onto a
+      # REUSED runner. `|| true` so a clean runner is not an error.
+      - name: Clear any leaked containers from a prior run
+        run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v --remove-orphans || true
+
+      - name: Start ${{ matrix.db }}
+        run: docker compose -f local/docker-compose.${{ matrix.db }}.yml up -d --wait
+
+      # `globalSetup` installs EQL v3 by shelling out to the real
+      # `stash eql install --eql-version 3`, so an installer regression fails
+      # here rather than hiding behind a test-only SQL apply.
+      - name: prisma-next v3 family suites
+        run: pnpm --filter @cipherstash/prisma-next run test:integration
+
+      - name: Stop ${{ matrix.db }}
+        if: always()
+        run: docker compose -f local/docker-compose.${{ matrix.db }}.yml down -v
diff --git a/packages/prisma-next/integration/adapter.ts b/packages/prisma-next/integration/adapter.ts
new file mode 100644
index 00000000..81be2bb1
--- /dev/null
+++ b/packages/prisma-next/integration/adapter.ts
@@ -0,0 +1,310 @@
+import { stripDomainSchema } from '@cipherstash/stack/adapter-kit'
+import {
+  databaseUrl,
+  type IntegrationAdapter,
+  type PlainRow,
+  type QueryOp,
+  type QueryOpKind,
+  type TableSpec,
+} from '@cipherstash/test-kit'
+import type { AnyExpression } from '@prisma-next/sql-relational-core/ast'
+import { ColumnRef, OrderByItem } from '@prisma-next/sql-relational-core/ast'
+import postgres from 'postgres'
+import { EncryptedBigInt } from '../src/execution/envelope-bigint'
+import { EncryptedBoolean } from '../src/execution/envelope-boolean'
+import { EncryptedDate } from '../src/execution/envelope-date'
+import { EncryptedJson } from '../src/execution/envelope-json'
+import { EncryptedString } from '../src/execution/envelope-string'
+import { toV3CodecId } from '../src/v3/catalog'
+import { EncryptedNumber } from '../src/v3/envelope-number'
+import { eqlAsc, eqlDesc } from '../src/v3/operators-v3'
+import {
+  createLiveTable,
+  insertEncryptedRows,
+  type LiveRowSpec,
+  type LiveV3Client,
+  liveV3Contract,
+  runLoweredSelect,
+  selectIdsOrderBy,
+  selectIdsWhere,
+  setupLiveV3,
+} from '../test/live/helpers/harness'
+import {
+  callOperator,
+  columnAccessorV3,
+  getOperator,
+} from '../test/v3/operator-lowering-v3.helpers'
+
+/**
+ * The prisma-next v3 adapter under real ZeroKMS ciphertext — the third
+ * first-party adapter behind the shared test-kit family driver, pinned
+ * against the same catalog, plaintext oracle, and single-vs-bulk insert
+ * crossover as the Drizzle and Supabase suites (PR #655 review ask #4).
+ *
+ * prisma-next has no `encryptModel`/`bulkEncryptModels` pair: its ONE
+ * encrypt path is the v3 bulk-encrypt middleware, which batches every
+ * envelope param of a statement. `insertSingle` therefore runs a
+ * one-row INSERT (one middleware crossing per row) and `insertBulk` a
+ * single multi-row INSERT (one crossing for the whole batch) — the two
+ * genuinely different batching shapes this integration exposes.
+ *
+ * Queries go through the REAL surface: operator lowering via the
+ * registered `eql*` operations, the postgres adapter's `lower`, and the
+ * middleware minting ciphertext-free `encryptQuery` terms — the same
+ * seam the ORM's `where((u) => u.col.eqlEq(...))` callback drives.
+ */
+
+const SUPPORTED_OPS: ReadonlySet<QueryOpKind> = new Set([
+  'eq',
+  'ne',
+  'in',
+  'notIn',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'between',
+  'notBetween',
+  'matches',
+  'order',
+  'isNull',
+  'isNotNull',
+])
+
+/** prisma-next talks straight to Postgres; nothing is refused adapter-wide. */
+const ALWAYS_REJECTED: ReadonlySet<QueryOpKind> = new Set()
+
+/** test-kit op kind → registered v3 operation method name. */
+const OP_METHOD = {
+  eq: 'eqlEq',
+  ne: 'eqlNeq',
+  in: 'eqlIn',
+  notIn: 'eqlNotIn',
+  gt: 'eqlGt',
+  gte: 'eqlGte',
+  lt: 'eqlLt',
+  lte: 'eqlLte',
+  between: 'eqlBetween',
+  notBetween: 'eqlNotBetween',
+  matches: 'eqlMatch',
+} as const
+
+/**
+ * Wrap a plaintext in the envelope class matching the domain's castAs —
+ * the shape the bulk-encrypt middleware expects for INSERT params.
+ */
+function envelopeFor(castAs: string, value: unknown): unknown {
+  if (value === null || value === undefined) return null
+  switch (castAs) {
+    case 'string':
+      return EncryptedString.from(value as string)
+    case 'number':
+      return EncryptedNumber.from(value as number)
+    case 'bigint':
+      return EncryptedBigInt.from(value as bigint)
+    case 'date':
+    case 'timestamp':
+      return EncryptedDate.from(value as Date)
+    case 'boolean':
+      return EncryptedBoolean.from(value as boolean)
+    case 'json':
+      return EncryptedJson.from(value)
+    default:
+      throw new Error(
+        `prisma-next integration adapter: unknown castAs "${castAs}"`,
+      )
+  }
+}
+
+export function makePrismaNextAdapter(): IntegrationAdapter {
+  let sql: postgres.Sql
+  let live: LiveV3Client
+  let contract: ReturnType<typeof liveV3Contract>
+  let tableName: string
+  /** column slug → v3 codec id, derived from the family's domains. */
+  let codecIds: Record<string, string>
+  /** column slug → the domain's castAs, for envelope construction. */
+  let castAsBySlug: Record<string, string>
+
+  const accessor = (slug: string) =>
+    columnAccessorV3(tableName, slug, codecIds[slug] as string)
+
+  /** Every op except `order`/`isNull`/`isNotNull` lowers through the v3 registry. */
+  const predicateFor = (op: QueryOp): AnyExpression => {
+    // `callOperator` (the shared lowering helper) already returns the
+    // built AST node — no further `buildAst()` step.
+    switch (op.kind) {
+      case 'eq':
+      case 'ne':
+      case 'gt':
+      case 'gte':
+      case 'lt':
+      case 'lte':
+        return callOperator(
+          getOperator(OP_METHOD[op.kind]),
+          accessor(op.column),
+          op.value,
+        )
+      case 'in':
+      case 'notIn':
+        return callOperator(
+          getOperator(OP_METHOD[op.kind]),
+          accessor(op.column),
+          [...op.values],
+        )
+      case 'between':
+      case 'notBetween':
+        return callOperator(
+          getOperator(OP_METHOD[op.kind]),
+          accessor(op.column),
+          op.lo,
+          op.hi,
+        )
+      case 'matches':
+        return callOperator(
+          getOperator(OP_METHOD.matches),
+          accessor(op.column),
+          op.needle,
+        )
+      default:
+        throw new Error(`predicateFor: ${op.kind} is not a lowered predicate`)
+    }
+  }
+
+  const toLiveRow = (spec: TableSpec, row: PlainRow): LiveRowSpec => ({
+    id: row.rowKey,
+    cells: Object.fromEntries(
+      spec.columns.map((c) => [
+        c.slug,
+        {
+          codecId: codecIds[c.slug] as string,
+          value: envelopeFor(
+            castAsBySlug[c.slug] as string,
+            row.values[c.slug] ?? null,
+          ),
+        },
+      ]),
+    ),
+  })
+
+  /** Structural NULL checks never carry encrypted operands — plain SQL. */
+  const runNullCheck = async (column: string, negated: boolean) => {
+    const rows = (await sql.unsafe(
+      `SELECT id FROM "${tableName}" WHERE "${column}" IS ${negated ? 'NOT ' : ''}NULL ORDER BY id ASC`,
+    )) as unknown as Array<{ id: string }>
+    return rows.map((row) => row.id)
+  }
+
+  return {
+    name: 'prisma-next',
+    supportedOps: SUPPORTED_OPS,
+    alwaysRejectedOps: ALWAYS_REJECTED,
+
+    async setup() {
+      sql = postgres(databaseUrl(), { prepare: false, onnotice: () => {} })
+      // Contract + client are built in `createTable`: they are derived from
+      // the family's column set, which does not exist yet.
+    },
+
+    async teardown() {
+      if (tableName) await sql.unsafe(`DROP TABLE IF EXISTS "${tableName}"`)
+      await sql.end()
+    },
+
+    async createTable(spec: TableSpec) {
+      tableName = spec.name
+      codecIds = Object.fromEntries(
+        spec.columns.map((c) => [
+          c.slug,
+          toV3CodecId(stripDomainSchema(c.eqlType)),
+        ]),
+      )
+      castAsBySlug = Object.fromEntries(
+        spec.columns.map((c) => [c.slug, c.spec.castAs]),
+      )
+      await createLiveTable(sql, spec.name, codecIds)
+      contract = liveV3Contract(spec.name, codecIds)
+      live = await setupLiveV3(contract)
+    },
+
+    async insertSingle(spec: TableSpec, row: PlainRow) {
+      await insertEncryptedRows(sql, live.middleware, tableName, [
+        toLiveRow(spec, row),
+      ])
+    },
+
+    async insertBulk(spec: TableSpec, rows: readonly PlainRow[]) {
+      await insertEncryptedRows(
+        sql,
+        live.middleware,
+        tableName,
+        rows.map((row) => toLiveRow(spec, row)),
+      )
+    },
+
+    async run(_spec: TableSpec, op: QueryOp): Promise<string[]> {
+      if (op.kind === 'isNull') return runNullCheck(op.column, false)
+      if (op.kind === 'isNotNull') return runNullCheck(op.column, true)
+
+      if (op.kind === 'order') {
+        const term =
+          op.direction === 'asc'
+            ? eqlAsc(accessor(op.column))
+            : eqlDesc(accessor(op.column))
+        // Break plaintext ties on `id`, mirroring the oracle's rowKey
+        // tie-break (domains with fewer distinct samples than rows seed
+        // duplicate plaintexts).
+        const ast = selectIdsOrderBy(tableName, [
+          term,
+          OrderByItem.asc(ColumnRef.of(tableName, 'id')),
+        ])
+        const { ids } = await runLoweredSelect(
+          sql,
+          live.middleware,
+          contract,
+          ast,
+        )
+        // The driver's contract excludes the all-NULL row from `order`
+        // results (NULL placement is a SQL-dialect property, not an
+        // encrypted-term property). Dropping it client-side preserves
+        // the database-produced order of the value rows.
+        const nullIds = new Set(await runNullCheck(op.column, false))
+        return ids.filter((id) => !nullIds.has(id))
+      }
+
+      const ast = selectIdsWhere(tableName, predicateFor(op))
+      const { ids } = await runLoweredSelect(
+        sql,
+        live.middleware,
+        contract,
+        ast,
+      )
+      return ids
+    },
+
+    async expectRejected(_spec: TableSpec, op: QueryOp) {
+      try {
+        if (op.kind === 'order') {
+          // `eqlAsc`/`eqlDesc` throw synchronously on a column with no
+          // ordering capability.
+          void (op.direction === 'asc'
+            ? eqlAsc(accessor(op.column))
+            : eqlDesc(accessor(op.column)))
+        } else if (op.kind === 'isNull' || op.kind === 'isNotNull') {
+          throw new Error(
+            `expectRejected(${op.kind}) is structural and never rejected for prisma-next`,
+          )
+        } else {
+          // Operator lowering gates on the domain's capabilities and
+          // throws `EncryptionOperatorError` before any encryption.
+          predicateFor(op)
+        }
+      } catch {
+        return // an `EncryptionOperatorError` is the rejection
+      }
+      throw new Error(
+        `Expected ${op.kind}("${op.column}") to be rejected, but it succeeded`,
+      )
+    },
+  }
+}
diff --git a/packages/prisma-next/integration/families.integration.test.ts b/packages/prisma-next/integration/families.integration.test.ts
new file mode 100644
index 00000000..65ee0efb
--- /dev/null
+++ b/packages/prisma-next/integration/families.integration.test.ts
@@ -0,0 +1,12 @@
+import { FAMILY_NAMES } from '@cipherstash/test-kit'
+import { runFamilySuite } from '@cipherstash/test-kit/suite'
+import { makePrismaNextAdapter } from './adapter'
+
+/**
+ * Every EQL v3 domain the SDK models, driven through the prisma-next adapter
+ * against real ZeroKMS ciphertext — the same catalog, oracle and driver as the
+ * Drizzle and Supabase suites, so the three cannot claim different coverage.
+ */
+for (const family of FAMILY_NAMES) {
+  runFamilySuite(family, makePrismaNextAdapter)
+}
diff --git a/packages/prisma-next/integration/vitest.config.ts b/packages/prisma-next/integration/vitest.config.ts
new file mode 100644
index 00000000..c14dd881
--- /dev/null
+++ b/packages/prisma-next/integration/vitest.config.ts
@@ -0,0 +1,22 @@
+import { resolve } from 'node:path'
+import { defineConfig } from 'vitest/config'
+import { sharedAlias, stackSourceAlias } from '../../../vitest.shared'
+import {
+  integrationHarness,
+  integrationTestDefaults,
+} from '../../test-kit/src/integration/config'
+
+/**
+ * Integration suites for the prisma-next adapter: real ZeroKMS + real
+ * Postgres. Runs only under `test:integration` (its own CI job). Harness +
+ * shared `test.*` knobs come from `@cipherstash/test-kit`.
+ */
+export default defineConfig({
+  resolve: { alias: { ...sharedAlias, ...stackSourceAlias } },
+  test: {
+    root: resolve(__dirname, '..'),
+    include: ['integration/**/*.integration.test.ts'],
+    ...integrationHarness,
+    ...integrationTestDefaults,
+  },
+})
diff --git a/packages/prisma-next/tsconfig.json b/packages/prisma-next/tsconfig.json
index 6ce239f2..75c46c15 100644
--- a/packages/prisma-next/tsconfig.json
+++ b/packages/prisma-next/tsconfig.json
@@ -5,6 +5,11 @@
     "module": "ESNext",
     "moduleDetection": "force",
     "moduleResolution": "bundler",
+    // Mirrors `packages/stack/tsconfig.json`: protect-ffi 0.24+ uses
+    // conditional exports, and bundler resolution omits `node` by
+    // default. Needed because the `@/*` mapping below pulls stack
+    // SOURCE (which imports protect-ffi types) into this program.
+    "customConditions": ["node"],
     "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "resolveJsonModule": true,
@@ -16,8 +21,19 @@
     "noFallthroughCasesInSwitch": true,
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "rootDir": "."
+    // No `rootDir` pin: the integration suite (like stack-drizzle's)
+    // pulls `@cipherstash/test-kit` SOURCE and the repo-root
+    // `vitest.shared.ts` into the program, which live outside this
+    // package. `noEmit` is set, so rootDir would only manufacture
+    // TS6059 errors here.
+    "baseUrl": ".",
+    "paths": {
+      // test-kit is a source-only package that consumes stack through
+      // the `@/` alias; mirror stack-drizzle's mapping so its sources
+      // typecheck inside this package's program.
+      "@/*": ["../stack/src/*"]
+    }
   },
-  "include": ["src/**/*.ts", "test/**/*.ts"],
+  "include": ["src/**/*.ts", "test/**/*.ts", "integration/**/*.ts"],
   "exclude": ["dist", "node_modules"]
 }
diff --git a/packages/test-kit/src/adapter.ts b/packages/test-kit/src/adapter.ts
index 5a06fd54..1140c334 100644
--- a/packages/test-kit/src/adapter.ts
+++ b/packages/test-kit/src/adapter.ts
@@ -10,7 +10,7 @@ import type { PlainRow, TableSpec } from './rows.ts'
  * operations while both suites read as "comprehensive".
  */
 export interface IntegrationAdapter {
-  readonly name: 'drizzle' | 'supabase' | 'wasm'
+  readonly name: 'drizzle' | 'supabase' | 'wasm' | 'prisma-next'
 
   /**
    * Operations this adapter can express at all, independent of any domain. Both

From 5a8e6da66b0dd7e3ca3e728250910da4e89aac57 Mon Sep 17 00:00:00 2001
From: Dan Draper <dan@cipherstash.com>
Date: Fri, 17 Jul 2026 16:20:00 +1000
Subject: [PATCH 19/21] fix(cli): stop init/plan/impl crashing on Prisma Next;
 ship stash-prisma-next skill
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SKILL_MAP was typed Record<Integration, ...> but omitted the 'prisma-next'
key, so installSkills and the AGENTS.md builder hit SKILL_MAP['prisma-next']
= undefined and threw 'not iterable' for any repo the CLI detected as Prisma
Next. tsc catches the missing key, but the build (tsup) transpiles without
type-checking, so the error shipped in rc.2 — reachable by any Prisma user
running stash init (Prisma Next is auto-detected).

- Add the prisma-next SKILL_MAP entry.
- Route both consumers through a new skillsFor() helper that degrades an
  unmapped integration to the base skill set (stash-encryption + stash-cli)
  instead of crashing — belt-and-braces for the next Integration variant,
  since tsup won't type-check the map.
- New skills/stash-prisma-next/SKILL.md documenting the EQL v3 Prisma Next
  surface: domain-named column types (EncryptedTextSearch, EncryptedDoubleOrd,
  ...), cipherstashFromStackV3 wiring, runtime envelopes, the eql* operators,
  and EQL install via prisma-next migration apply (not stash eql install).
- Tests: SKILL_MAP has a non-empty entry for every integration; skillsFor
  falls back for an unmapped one; buildAgentsMdBody('prisma-next', ...) inlines
  the skill (the exact call that used to crash); installSkills copies it.
- Meta: AGENTS.md skill-map table + skills list updated.

Companion to #655 (the @cipherstash/prisma-next EQL v3 package) — that PR
releases the package but touches no CLI code, so this crash survives it.
Stacked on feat/prisma-next-eql-v3; retarget to main when #655 lands.

Claude-Session: https://claude.ai/code/session_01MxTTPaPP16m6br7Hoab94w
---
 .changeset/stash-prisma-next-skill.md         |  19 ++
 AGENTS.md                                     |   4 +-
 .../lib/__tests__/build-agents-md.test.ts     |   9 +
 .../init/lib/__tests__/install-skills.test.ts |  43 ++++
 .../src/commands/init/lib/build-agents-md.ts  |   4 +-
 .../src/commands/init/lib/install-skills.ts   |  20 +-
 skills/stash-prisma-next/SKILL.md             | 234 ++++++++++++++++++
 7 files changed, 328 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/stash-prisma-next-skill.md
 create mode 100644 skills/stash-prisma-next/SKILL.md

diff --git a/.changeset/stash-prisma-next-skill.md b/.changeset/stash-prisma-next-skill.md
new file mode 100644
index 00000000..289d44a7
--- /dev/null
+++ b/.changeset/stash-prisma-next-skill.md
@@ -0,0 +1,19 @@
+---
+'stash': minor
+---
+
+`stash init`, `stash plan`, and `stash impl` no longer crash on a Prisma Next
+project. `SKILL_MAP` was missing a `prisma-next` entry, so the skills-install
+and AGENTS.md-builder steps hit `SKILL_MAP[integration]` → `undefined` and threw
+"not iterable" for any repo the CLI detected as Prisma Next. The entry is added
+and both consumers now resolve skills through a `skillsFor()` helper that
+degrades an unmapped integration to the base skill set instead of crashing
+(`tsup` ships without type-checking, so the `Record<Integration>` type alone
+didn't protect the build).
+
+Ships a new **`stash-prisma-next`** agent skill documenting the EQL v3 Prisma
+Next surface — the domain-named encrypted column types (`EncryptedTextSearch`,
+`EncryptedDoubleOrd`, …), `cipherstashFromStackV3` wiring, the runtime value
+envelopes, the `eql*` query operators, and EQL installation via
+`prisma-next migration apply`. It is installed for Prisma Next projects and
+inlined into `AGENTS.md` for editor agents.
diff --git a/AGENTS.md b/AGENTS.md
index 4b14ad90..6ce4c707 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -92,7 +92,7 @@ If these variables are missing, tests that require live encryption will fail or
 - `e2e/*`: Cross-package end-to-end tests (package managers, supply chain, Prisma example README)
 - `examples/*`: Working apps (basic, prisma, supabase-worker)
 - `docs/plans/*`: Internal design plans. User-facing documentation lives at https://cipherstash.com/docs (not in this repo).
-- `skills/*`: Agent skills (`stash-cli`, `stash-encryption`, `stash-drizzle`, `stash-dynamodb`, `stash-supabase`, `stash-supply-chain-security`)
+- `skills/*`: Agent skills (`stash-cli`, `stash-encryption`, `stash-drizzle`, `stash-dynamodb`, `stash-supabase`, `stash-prisma-next`, `stash-supply-chain-security`)
 
 ## Agent Skills — these ship to customers
 
@@ -115,7 +115,7 @@ nothing type-checks them, and the damage lands in a customer's repo, not ours.
 |---|---|
 | `packages/cli` commands, flags, or prompts | `skills/stash-cli` |
 | `packages/stack` encryption API, schema builders, subpath exports | `skills/stash-encryption` |
-| Drizzle / Supabase / DynamoDB integrations | `skills/stash-drizzle`, `skills/stash-supabase`, `skills/stash-dynamodb` |
+| Drizzle / Supabase / Prisma Next / DynamoDB integrations | `skills/stash-drizzle`, `skills/stash-supabase`, `skills/stash-prisma-next`, `skills/stash-dynamodb` |
 | The rollout/cutover lifecycle (`packages/migrate`, `stash encrypt *`) | `skills/stash-encryption` and `skills/stash-cli` |
 | pnpm config, CI workflows, dependency policy | `skills/stash-supply-chain-security` |
 | The durable agent rules themselves | `packages/cli/src/commands/init/doctrine/AGENTS-doctrine.md` |
diff --git a/packages/cli/src/commands/init/lib/__tests__/build-agents-md.test.ts b/packages/cli/src/commands/init/lib/__tests__/build-agents-md.test.ts
index 9aebdb34..b87532e1 100644
--- a/packages/cli/src/commands/init/lib/__tests__/build-agents-md.test.ts
+++ b/packages/cli/src/commands/init/lib/__tests__/build-agents-md.test.ts
@@ -51,4 +51,13 @@ describe('buildAgentsMdBody', () => {
     expect(out).not.toContain('# Skill: stash-drizzle')
     expect(out).not.toContain('# Skill: stash-supabase')
   })
+
+  it('prisma-next inlines the stash-prisma-next skill (no crash on undefined map)', () => {
+    // Regression: SKILL_MAP once lacked a prisma-next key, so this call
+    // threw "SKILL_MAP[integration] is not iterable" for any Prisma repo.
+    const out = buildAgentsMdBody('prisma-next', 'doctrine-plus-skills')
+    expect(out).toContain('# Skill: stash-prisma-next')
+    expect(out).toContain('# Skill: stash-encryption')
+    expect(out).not.toContain('# Skill: stash-drizzle')
+  })
 })
diff --git a/packages/cli/src/commands/init/lib/__tests__/install-skills.test.ts b/packages/cli/src/commands/init/lib/__tests__/install-skills.test.ts
index cefb345b..1a1db19e 100644
--- a/packages/cli/src/commands/init/lib/__tests__/install-skills.test.ts
+++ b/packages/cli/src/commands/init/lib/__tests__/install-skills.test.ts
@@ -2,13 +2,35 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { Integration } from '../../types.js'
 import {
   installSkills,
   readBundledSkill,
   SKILL_MAP,
+  skillsFor,
 } from '../install-skills.js'
 
+// Every integration the init flow can resolve to. Kept in lockstep with the
+// `Integration` union and the init provider registry — a new integration added
+// without a SKILL_MAP entry crashes the skills install and the AGENTS.md builder
+// (SKILL_MAP[integration] is undefined → "not iterable"), and `tsup` ships that
+// without type-checking, so this list is the runtime guard tsc can't be.
+const ALL_INTEGRATIONS: Integration[] = [
+  'drizzle',
+  'supabase',
+  'prisma-next',
+  'postgresql',
+]
+
 describe('SKILL_MAP', () => {
+  it('has a non-empty entry for every integration (no undefined → crash)', () => {
+    for (const integration of ALL_INTEGRATIONS) {
+      const skills = SKILL_MAP[integration]
+      expect(skills, integration).toBeDefined()
+      expect(skills.length, integration).toBeGreaterThan(0)
+    }
+  })
+
   it('always includes stash-encryption and stash-cli for every integration', () => {
     for (const [integration, skills] of Object.entries(SKILL_MAP)) {
       expect(skills, integration).toContain('stash-encryption')
@@ -24,9 +46,30 @@ describe('SKILL_MAP', () => {
     expect(SKILL_MAP.supabase).toContain('stash-supabase')
   })
 
+  it('prisma-next includes stash-prisma-next', () => {
+    expect(SKILL_MAP['prisma-next']).toContain('stash-prisma-next')
+  })
+
   it('postgresql skips ORM-specific skills', () => {
     expect(SKILL_MAP.postgresql).not.toContain('stash-drizzle')
     expect(SKILL_MAP.postgresql).not.toContain('stash-supabase')
+    expect(SKILL_MAP.postgresql).not.toContain('stash-prisma-next')
+  })
+})
+
+describe('skillsFor', () => {
+  it('returns the mapped skills for a known integration', () => {
+    expect(skillsFor('prisma-next')).toEqual([
+      'stash-encryption',
+      'stash-prisma-next',
+      'stash-cli',
+    ])
+  })
+
+  it('falls back to the base skills for an unmapped integration (never crashes)', () => {
+    // Simulate a future Integration variant with no SKILL_MAP entry.
+    const skills = skillsFor('mystery-orm' as Integration)
+    expect(skills).toEqual(['stash-encryption', 'stash-cli'])
   })
 })
 
diff --git a/packages/cli/src/commands/init/lib/build-agents-md.ts b/packages/cli/src/commands/init/lib/build-agents-md.ts
index 2885d637..fcdadf99 100644
--- a/packages/cli/src/commands/init/lib/build-agents-md.ts
+++ b/packages/cli/src/commands/init/lib/build-agents-md.ts
@@ -3,7 +3,7 @@ import { join } from 'node:path'
 import * as p from '@clack/prompts'
 import type { Integration } from '../types.js'
 import { findBundledDir } from './bundled-paths.js'
-import { readBundledSkill, SKILL_MAP } from './install-skills.js'
+import { readBundledSkill, skillsFor } from './install-skills.js'
 
 export type AgentsMdMode = 'doctrine-only' | 'doctrine-plus-skills'
 
@@ -41,7 +41,7 @@ export function buildAgentsMdBody(
 
   if (mode === 'doctrine-plus-skills') {
     const skillBodies: string[] = []
-    for (const name of SKILL_MAP[integration]) {
+    for (const name of skillsFor(integration)) {
       const body = readBundledSkill(name)
       if (body) {
         skillBodies.push(`---\n\n# Skill: ${name}\n\n${stripFrontmatter(body)}`)
diff --git a/packages/cli/src/commands/init/lib/install-skills.ts b/packages/cli/src/commands/init/lib/install-skills.ts
index ce368e11..9cb10410 100644
--- a/packages/cli/src/commands/init/lib/install-skills.ts
+++ b/packages/cli/src/commands/init/lib/install-skills.ts
@@ -13,9 +13,27 @@ import { findBundledDir } from './bundled-paths.js'
 export const SKILL_MAP: Record<Integration, readonly string[]> = {
   drizzle: ['stash-encryption', 'stash-drizzle', 'stash-cli'],
   supabase: ['stash-encryption', 'stash-supabase', 'stash-cli'],
+  'prisma-next': ['stash-encryption', 'stash-prisma-next', 'stash-cli'],
   postgresql: ['stash-encryption', 'stash-cli'],
 }
 
+/** The skills every integration gets — the safe fallback for an unmapped one. */
+const BASE_SKILLS: readonly string[] = ['stash-encryption', 'stash-cli']
+
+/**
+ * Skills for an integration, resilient to an unmapped one. `SKILL_MAP` is
+ * typed `Record<Integration, …>`, but the build (`tsup`) transpiles without
+ * type-checking — so a new `Integration` variant added without a `SKILL_MAP`
+ * entry would ship as `undefined` and crash both consumers (`installSkills`,
+ * the AGENTS.md builder) with "not iterable". Degrade to the base skill set
+ * instead: the user still gets `stash-encryption` + `stash-cli`, never a
+ * stack trace. (Regression-guarded by a test that pins SKILL_MAP's keys to
+ * the init provider registry.)
+ */
+export function skillsFor(integration: Integration): readonly string[] {
+  return SKILL_MAP[integration] ?? BASE_SKILLS
+}
+
 /**
  * Copy the per-integration set of skills into `<cwd>/<destDir>/<skill>/`.
  *
@@ -34,7 +52,7 @@ export function installSkills(
   destDir: string,
   integration: Integration,
 ): string[] {
-  const skills = SKILL_MAP[integration]
+  const skills = skillsFor(integration)
   const bundledRoot = findBundledDir('skills')
   if (!bundledRoot) {
     p.log.warn(
diff --git a/skills/stash-prisma-next/SKILL.md b/skills/stash-prisma-next/SKILL.md
new file mode 100644
index 00000000..ab1f41ef
--- /dev/null
+++ b/skills/stash-prisma-next/SKILL.md
@@ -0,0 +1,234 @@
+---
+name: stash-prisma-next
+description: Integrate CipherStash searchable field-level encryption with Prisma Next using @cipherstash/prisma-next (EQL v3). Covers the domain-named encrypted column types in schema.prisma (EncryptedTextSearch, EncryptedDoubleOrd, EncryptedBigIntOrd, EncryptedDateOrd, EncryptedBoolean, EncryptedJson), the one-call cipherstashFromStackV3 wiring, the runtime value envelopes (EncryptedString/Number/BigInt/Date/Boolean/Json) and decryptAll, the eql* query operators (eqlEq, eqlMatch, eqlGt, eqlBetween, eqlIn, eqlJsonContains, eqlAsc/eqlDesc), EQL bundle installation via prisma-next migration apply, and authentication. Use when adding encryption to a Prisma Next project or querying encrypted columns.
+---
+
+# CipherStash Stack — Prisma Next Integration
+
+Guide for searchable field-level encryption in a **Prisma Next** app with
+`@cipherstash/prisma-next` (EQL v3), powered by `@cipherstash/stack`. You declare
+encrypted columns directly in `schema.prisma`; Prisma Next's migration system
+installs the EQL bundle in the same sweep that creates your tables — there is no
+separate `stash eql install` step.
+
+> This is the **EQL v3** surface (the documented one). A legacy EQL v2 surface
+> exists for existing deployments (`cipherstashFromStack` from
+> `@cipherstash/prisma-next/stack`, `cipherstash*` operators); everything below
+> is v3. New projects use v3.
+
+In EQL v3 every encrypted column is a **concrete Postgres domain**
+(`public.eql_v3_text_search`, `public.eql_v3_double_ord`, …) whose query
+capabilities are fixed by the column type you choose — there is no capability
+config object. See the `stash-encryption` skill for the domain catalog and
+capability semantics; this skill covers the Prisma-Next-specific surface.
+
+## When to Use This Skill
+
+- Adding field-level encryption to a Prisma Next project
+- Declaring encrypted columns in `schema.prisma`
+- Querying encrypted columns with the `eql*` operators
+- Wiring the runtime with `cipherstashFromStackV3`
+
+## Installation
+
+```bash
+npm install @cipherstash/stack @cipherstash/prisma-next
+```
+
+Or run `npx stash init --prisma-next`, which detects Prisma Next, installs both
+packages pinned to the CLI release, authenticates, and scaffolds the wiring.
+
+## The three wiring points
+
+### 1. Declare encrypted columns in `schema.prisma`
+
+The column types are **domain-named** — the name encodes the query capability
+(matching the `@cipherstash/stack` `types.*` catalog), not a generic primitive:
+
+```prisma
+model User {
+  id            String @id
+  email         cipherstash.EncryptedTextSearch()  // eq + range + free-text + ORDER BY
+  salary        cipherstash.EncryptedDoubleOrd()   // eq + range + ORDER BY
+  accountId     cipherstash.EncryptedBigIntOrd()   // eq + range + ORDER BY
+  birthday      cipherstash.EncryptedDateOrd()     // eq + range + ORDER BY
+  emailVerified cipherstash.EncryptedBoolean()     // storage-only (no operators)
+  preferences   cipherstash.EncryptedJson()        // containment (@>)
+}
+```
+
+| Column type | Domain | Query capability |
+|---|---|---|
+| `EncryptedTextSearch()` | `eql_v3_text_search` | equality, range, free-text, ORDER BY |
+| `EncryptedDoubleOrd()` | `eql_v3_double_ord` | equality, range, ORDER BY |
+| `EncryptedBigIntOrd()` | `eql_v3_bigint_ord` | equality, range, ORDER BY |
+| `EncryptedDateOrd()` | `eql_v3_date_ord` | equality, range, ORDER BY |
+| `EncryptedBoolean()` | `eql_v3_boolean` | storage-only (no operators) |
+| `EncryptedJson()` | `eql_v3_json` | containment (`@>`) |
+
+Choose the column type by the queries you need: a value you only store and
+decrypt (never search) can use a storage-only domain; a value you filter or sort
+on needs the matching `*Ord` / `TextSearch` domain. The type is fixed at the
+column — there is no capability tuner.
+
+### 2. Register the extension pack in `prisma-next.config.ts`
+
+```typescript
+import cipherstash from '@cipherstash/prisma-next/control'
+import { defineConfig } from 'prisma-next'
+// ... family, target, adapter, contract
+
+export default defineConfig({
+  // ... your existing config
+  extensionPacks: [cipherstash],
+})
+```
+
+### 3. Wire the runtime with `cipherstashFromStackV3` in `src/db.ts`
+
+```typescript
+import 'dotenv/config'
+import { cipherstashFromStackV3 } from '@cipherstash/prisma-next/v3'
+import postgres from '@prisma-next/postgres/runtime'
+import type { Contract } from './prisma/contract.d'
+import contractJson from './prisma/contract.json' with { type: 'json' }
+
+const cipherstash = await cipherstashFromStackV3({ contractJson })
+
+export const db = postgres<Contract>({
+  contractJson,
+  extensions: cipherstash.extensions,
+  middleware: cipherstash.middleware,
+})
+```
+
+`cipherstashFromStackV3({ contractJson })` derives the v3 encryption schemas from
+the contract (one `public.eql_v3_*` domain per column), constructs the
+`@cipherstash/stack` `EncryptionV3` client from your `CS_*` env vars or local
+profile, builds the SDK adapter, and returns ready-to-spread `extensions` and
+`middleware`. A v3 client is v3-only — a contract carrying v2 codec ids is
+rejected at setup (use `cipherstashFromStack` from
+`@cipherstash/prisma-next/stack` for a v2 contract).
+
+## Install the EQL bundle (part of your migration, not a separate step)
+
+The extension pack contributes its own contract space at
+`migrations/cipherstash/`, so the EQL bundle installs alongside your application
+schema:
+
+```bash
+npx stash auth login                 # one-time, per developer
+npx prisma-next contract emit
+npx prisma-next migration plan --name initial
+npx prisma-next migration apply      # installs EQL bundle + your schema
+```
+
+Do **not** run `stash eql install` for a Prisma Next project — `prisma-next
+migration apply` owns EQL installation, and `stash init --prisma-next` skips the
+standalone installer for exactly this reason.
+
+## Writing and reading encrypted values
+
+At the value boundary you wrap plaintext in a **runtime envelope** (primitive-named,
+distinct from the domain-named column type) and unwrap with `decryptAll` +
+`.decrypt()`:
+
+```typescript
+import {
+  decryptAll,
+  EncryptedString, EncryptedNumber, EncryptedBigInt,
+  EncryptedDate, EncryptedBoolean, EncryptedJson,
+} from '@cipherstash/prisma-next/runtime'
+
+await db.orm.public.User.create({
+  id: 'user-0',
+  email: EncryptedString.from('alice@example.com'),
+  salary: EncryptedNumber.from(100_000),      // EncryptedDoubleOrd column
+  accountId: EncryptedBigInt.from(100_000_000_001n),
+  birthday: EncryptedDate.from(new Date('1990-01-01')),
+  emailVerified: EncryptedBoolean.from(true),
+  preferences: EncryptedJson.from({ theme: 'dark' }),
+})
+
+const rows = await db.orm.public.User.where((u) => u.email.eqlEq('alice@example.com')).all()
+await decryptAll(rows)                          // batches one SDK round-trip per (table,column)
+console.log(await rows[0]?.email.decrypt())     // 'alice@example.com'
+```
+
+The envelope for a `double` column is `EncryptedNumber` (JS `number`); the schema
+column type is `EncryptedDoubleOrd`. Envelope ↔ column pairing: `EncryptedString`
+↔ `EncryptedTextSearch`, `EncryptedNumber` ↔ `EncryptedDoubleOrd`,
+`EncryptedBigInt` ↔ `EncryptedBigIntOrd`, `EncryptedDate` ↔ `EncryptedDateOrd`,
+`EncryptedBoolean` ↔ `EncryptedBoolean`, `EncryptedJson` ↔ `EncryptedJson`.
+
+## Query operators (`eql*`)
+
+Operators live on the encrypted column inside `.where((u) => …)` and encrypt the
+search term for you — Prisma Next never sees plaintext in a query. EQL v3 uses the
+EQL-derived `eql*` vocabulary (the legacy v2 surface keeps `cipherstash*` names):
+
+| Operator | Meaning | Requires |
+|---|---|---|
+| `eqlEq(v)` / `eqlNeq(v)` | equality / inequality | any searchable domain |
+| `eqlIn(vs)` / `eqlNotIn(vs)` | membership | any searchable domain |
+| `eqlMatch(term)` | free-text token match (`eql_v3.contains`) | `EncryptedTextSearch` |
+| `eqlGt/eqlGte/eqlLt/eqlLte(v)` | range comparison | an `*Ord` domain |
+| `eqlBetween(lo,hi)` / `eqlNotBetween(lo,hi)` | range window | an `*Ord` domain |
+| `eqlAsc()` / `eqlDesc()` | ORDER BY | an `*Ord` or `TextSearch` domain |
+| `eqlJsonContains(obj)` | encrypted JSON containment (`@>`) | `EncryptedJson` |
+
+```typescript
+// range
+await db.orm.public.User.where((u) => u.salary.eqlGt(100_000)).all()
+// free-text
+await db.orm.public.User.where((u) => u.email.eqlMatch('example.com')).all()
+// between
+await db.orm.public.User.where((u) => u.birthday.eqlBetween(lo, hi)).all()
+// bigint membership
+await db.orm.public.User.where((u) => u.accountId.eqlIn([100_000_000_001n])).all()
+// encrypted JSON containment
+await db.orm.public.User.where((u) => u.preferences.eqlJsonContains({ theme: 'dark' })).all()
+// ordering
+import { eqlAsc } from '@cipherstash/prisma-next/runtime'
+await db.orm.public.User.orderBy((u) => eqlAsc(u.salary)).all()
+```
+
+Applying an operator its domain doesn't support (e.g. `eqlGt` on a
+storage-only `EncryptedBoolean`, or `eqlMatch` on a non-text domain) is a typed
+error at build time, not a runtime surprise.
+
+## Authentication
+
+Same credential model as the rest of Stack:
+
+- **Local dev:** `npx stash auth login` (device-code flow; token in `~/.cipherstash`).
+- **CI / production:** the four `CS_*` env vars (`CS_WORKSPACE_CRN`, `CS_CLIENT_ID`,
+  `CS_CLIENT_KEY`, `CS_CLIENT_ACCESS_KEY`). See the `stash-cli` and
+  `stash-encryption` skills for how to obtain them from your device session.
+
+`cipherstashFromStackV3` resolves `CS_*` when present, else the local profile.
+
+## Bundling
+
+`@cipherstash/stack` wraps a native FFI module and must be excluded from bundling
+(`serverExternalPackages`, esbuild `external`, etc.) — see the `stash-encryption`
+skill's bundling section. For edge/serverless runtimes without the native module,
+use `@cipherstash/stack/wasm-inline`.
+
+## Subpath exports
+
+| Subpath | Purpose |
+|---|---|
+| `@cipherstash/prisma-next/v3` | The v3 surface: `cipherstashFromStackV3`, the SDK adapter, envelopes/middleware |
+| `@cipherstash/prisma-next/control` | The extension pack for `extensionPacks: [...]` |
+| `@cipherstash/prisma-next/runtime` | Envelope classes, `decryptAll`, `eql*` operators, `EncryptedString.from()`… |
+| `@cipherstash/prisma-next/stack` | Legacy EQL v2 one-call setup (`cipherstashFromStack`) |
+
+## Gotchas
+
+- **EQL installs via `prisma-next migration apply`, never `stash eql install`.**
+- **Column type (schema, domain-named) ≠ runtime envelope (value, primitive-named).**
+  `EncryptedDoubleOrd` column ↔ `EncryptedNumber.from(...)` value.
+- **A v3 client rejects a v2 contract** at `cipherstashFromStackV3`. Regenerate the
+  contract (`prisma-next contract emit`) after switching a column to a v3 type.
+- **Never log or read `~/.cipherstash`** or `.env*` credential files (see `stash-cli`).

From 82796a72e480641b409e1c48ada338d7729f3191 Mon Sep 17 00:00:00 2001
From: Dan Draper <dan@cipherstash.com>
Date: Fri, 17 Jul 2026 17:13:28 +1000
Subject: [PATCH 20/21] docs(skills): fix three factual errors in
 stash-prisma-next flagged on #683
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- init does NOT scaffold wiring for Prisma Next (it skips the
  encryption-client scaffold — schema is derived from contract.json);
  say so instead of 'scaffolds the wiring'. (Copilot)
- eqlAsc/eqlDesc are free functions taking the column expression
  (eqlAsc(u.salary)), not zero-arg methods; fix the ORDER BY table row
  to match the code example. (Copilot)
- install-skills.ts: the skillsFor regression guard is a test asserting
  SKILL_MAP has an entry for every value in a maintained ALL_INTEGRATIONS
  list, not one that reads the provider registry; correct the comment. (Copilot)

Claude-Session: https://claude.ai/code/session_01MxTTPaPP16m6br7Hoab94w
---
 packages/cli/src/commands/init/lib/install-skills.ts | 4 ++--
 skills/stash-prisma-next/SKILL.md                    | 7 +++++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/packages/cli/src/commands/init/lib/install-skills.ts b/packages/cli/src/commands/init/lib/install-skills.ts
index 9cb10410..7c16310e 100644
--- a/packages/cli/src/commands/init/lib/install-skills.ts
+++ b/packages/cli/src/commands/init/lib/install-skills.ts
@@ -27,8 +27,8 @@ const BASE_SKILLS: readonly string[] = ['stash-encryption', 'stash-cli']
  * entry would ship as `undefined` and crash both consumers (`installSkills`,
  * the AGENTS.md builder) with "not iterable". Degrade to the base skill set
  * instead: the user still gets `stash-encryption` + `stash-cli`, never a
- * stack trace. (Regression-guarded by a test that pins SKILL_MAP's keys to
- * the init provider registry.)
+ * stack trace. (Regression-guarded by a test asserting SKILL_MAP has a
+ * non-empty entry for every value in a maintained `ALL_INTEGRATIONS` list.)
  */
 export function skillsFor(integration: Integration): readonly string[] {
   return SKILL_MAP[integration] ?? BASE_SKILLS
diff --git a/skills/stash-prisma-next/SKILL.md b/skills/stash-prisma-next/SKILL.md
index ab1f41ef..6a4fa83e 100644
--- a/skills/stash-prisma-next/SKILL.md
+++ b/skills/stash-prisma-next/SKILL.md
@@ -36,7 +36,10 @@ npm install @cipherstash/stack @cipherstash/prisma-next
 ```
 
 Or run `npx stash init --prisma-next`, which detects Prisma Next, installs both
-packages pinned to the CLI release, authenticates, and scaffolds the wiring.
+packages pinned to the CLI release, and authenticates. It does **not** scaffold
+the wiring files — Prisma Next derives its schema from `contract.json`, so there
+is no encryption-client file to generate; init prints the next steps (declare
+encrypted columns, emit the contract, run the migration) instead.
 
 ## The three wiring points
 
@@ -174,7 +177,7 @@ EQL-derived `eql*` vocabulary (the legacy v2 surface keeps `cipherstash*` names)
 | `eqlMatch(term)` | free-text token match (`eql_v3.contains`) | `EncryptedTextSearch` |
 | `eqlGt/eqlGte/eqlLt/eqlLte(v)` | range comparison | an `*Ord` domain |
 | `eqlBetween(lo,hi)` / `eqlNotBetween(lo,hi)` | range window | an `*Ord` domain |
-| `eqlAsc()` / `eqlDesc()` | ORDER BY | an `*Ord` or `TextSearch` domain |
+| `eqlAsc(col)` / `eqlDesc(col)` | ORDER BY (free functions, take the column) | an `*Ord` or `TextSearch` domain |
 | `eqlJsonContains(obj)` | encrypted JSON containment (`@>`) | `EncryptedJson` |
 
 ```typescript

From 29d0ea59dd14f46c72fbe6beeb10052e55657086 Mon Sep 17 00:00:00 2001
From: Dan Draper <dan@cipherstash.com>
Date: Fri, 17 Jul 2026 17:23:13 +1000
Subject: [PATCH 21/21] feat(cli): refuse `stash eql install` in a Prisma Next
 project (#683)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Prisma Next installs the EQL bundle through its own migration ledger
(migrations/cipherstash/ applied by `prisma-next migration apply`), so the
standalone installer is the wrong tool — running it applies EQL out-of-band
from the framework's ledger. `stash init --prisma-next` already skips the
installer; this closes the manual-invocation hole.

- New pure `prismaNextInstallGuard(cwd, { force })` (mirrors
  validateInstallFlags): returns actionable guidance when a Prisma Next
  project is detected and --force isn't set, else null. Called early in
  installCommand, before any DB I/O — fails fast with a pointer to
  `prisma-next migration apply`.
- --force overrides (deliberate standalone install escape hatch).
- messages.eql.prismaNextDetected as the stable leader.
- Tests: 4 unit (config-file detection, dep detection, --force override,
  non-prisma-next passthrough) + 1 pty-less e2e proving the wiring (refuses,
  exit 1, no DB). Skill gotcha + changeset updated.

Addresses CJ/Dan's #683 review ask to enforce this in the CLI.

Claude-Session: https://claude.ai/code/session_01MxTTPaPP16m6br7Hoab94w
---
 .changeset/stash-prisma-next-skill.md         |  5 ++
 .../prisma-next-install-guard.test.ts         | 54 +++++++++++++++++++
 packages/cli/src/commands/db/install.ts       | 39 ++++++++++++++
 packages/cli/src/messages.ts                  |  7 +++
 .../e2e/eql-install-prisma-next.e2e.test.ts   | 35 ++++++++++++
 skills/stash-prisma-next/SKILL.md             |  4 +-
 6 files changed, 143 insertions(+), 1 deletion(-)
 create mode 100644 packages/cli/src/commands/db/__tests__/prisma-next-install-guard.test.ts
 create mode 100644 packages/cli/tests/e2e/eql-install-prisma-next.e2e.test.ts

diff --git a/.changeset/stash-prisma-next-skill.md b/.changeset/stash-prisma-next-skill.md
index 289d44a7..a1617d52 100644
--- a/.changeset/stash-prisma-next-skill.md
+++ b/.changeset/stash-prisma-next-skill.md
@@ -17,3 +17,8 @@ Next surface — the domain-named encrypted column types (`EncryptedTextSearch`,
 envelopes, the `eql*` query operators, and EQL installation via
 `prisma-next migration apply`. It is installed for Prisma Next projects and
 inlined into `AGENTS.md` for editor agents.
+
+`stash eql install` now refuses to run in a Prisma Next project (pointing you
+at `prisma-next migration apply`, which owns EQL installation) unless you pass
+`--force` — closing the manual-invocation hole that `stash init --prisma-next`
+already avoided.
diff --git a/packages/cli/src/commands/db/__tests__/prisma-next-install-guard.test.ts b/packages/cli/src/commands/db/__tests__/prisma-next-install-guard.test.ts
new file mode 100644
index 00000000..6661faf3
--- /dev/null
+++ b/packages/cli/src/commands/db/__tests__/prisma-next-install-guard.test.ts
@@ -0,0 +1,54 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { messages } from '../../../messages.js'
+import { prismaNextInstallGuard } from '../install.js'
+
+describe('prismaNextInstallGuard', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'pn-install-guard-'))
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it('blocks with actionable guidance when a prisma-next.config is present', () => {
+    writeFileSync(join(dir, 'prisma-next.config.ts'), 'export default {}')
+
+    const msg = prismaNextInstallGuard(dir, {})
+    expect(msg).not.toBeNull()
+    expect(msg).toContain(messages.eql.prismaNextDetected)
+    expect(msg).toContain('prisma-next migration apply')
+    expect(msg).toContain('--force')
+  })
+
+  it('blocks when @cipherstash/prisma-next is a dependency', () => {
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({ dependencies: { '@cipherstash/prisma-next': '1.0.0' } }),
+    )
+
+    expect(prismaNextInstallGuard(dir, {})).toContain(
+      messages.eql.prismaNextDetected,
+    )
+  })
+
+  it('returns null (allows) with --force, even in a prisma-next project', () => {
+    writeFileSync(join(dir, 'prisma-next.config.ts'), 'export default {}')
+
+    expect(prismaNextInstallGuard(dir, { force: true })).toBeNull()
+  })
+
+  it('returns null (allows) when the project is not Prisma Next', () => {
+    writeFileSync(
+      join(dir, 'package.json'),
+      JSON.stringify({
+        dependencies: { '@cipherstash/stack-drizzle': '1.0.0' },
+      }),
+    )
+
+    expect(prismaNextInstallGuard(dir, {})).toBeNull()
+  })
+})
diff --git a/packages/cli/src/commands/db/install.ts b/packages/cli/src/commands/db/install.ts
index adcb5954..7ce8f6aa 100644
--- a/packages/cli/src/commands/db/install.ts
+++ b/packages/cli/src/commands/db/install.ts
@@ -18,10 +18,12 @@ import {
   loadBundledEqlSql,
   resolveEqlVersion,
 } from '@/installer/index.js'
+import { messages } from '@/messages.js'
 import { ensureEncryptionClient } from './client-scaffold.js'
 import { offerStashConfig } from './config-scaffold.js'
 import {
   detectDrizzle,
+  detectPrismaNext,
   detectSupabase,
   detectSupabaseProject,
   type SupabaseProjectInfo,
@@ -181,6 +183,17 @@ export async function installCommand(options: InstallOptions) {
     process.exit(1)
   }
 
+  // Prisma Next owns EQL installation via its own migration system, so the
+  // standalone installer is the wrong tool here. Refuse (before any DB I/O)
+  // unless --force. Fires fast so a user who typed the wrong command gets a
+  // pointer, not a half-applied install.
+  const prismaNextBlock = prismaNextInstallGuard(process.cwd(), options)
+  if (prismaNextBlock) {
+    p.log.error(prismaNextBlock)
+    p.outro('Installation aborted.')
+    process.exit(1)
+  }
+
   const s = p.spinner()
 
   // `eql install` only needs a database URL to install EQL. It does NOT require
@@ -629,6 +642,32 @@ export function routeInstallPathForEqlVersion(
   }
 }
 
+/**
+ * `stash eql install` is the wrong tool in a Prisma Next project: Prisma Next
+ * contributes a `migrations/cipherstash/` control space that installs the EQL
+ * bundle as part of `prisma-next migration apply`, in the same ledger as the
+ * app schema. Running the standalone installer applies EQL out-of-band from
+ * that ledger. `stash init --prisma-next` already skips the installer; this
+ * guards the manual-invocation path too.
+ *
+ * Returns the guidance string when the install should be blocked, else null.
+ * `--force` overrides (an escape hatch for a deliberate standalone install).
+ * Pure + cwd-injected so it unit-tests without a real project.
+ */
+export function prismaNextInstallGuard(
+  cwd: string,
+  options: Pick<InstallOptions, 'force'>,
+): string | null {
+  if (options.force) return null
+  if (!detectPrismaNext(cwd)) return null
+  return (
+    `${messages.eql.prismaNextDetected} (found prisma-next.config.* or @cipherstash/prisma-next). ` +
+    'Prisma Next installs the EQL bundle through its own migration system — run ' +
+    '`prisma-next migration apply` instead of `stash eql install`. ' +
+    'Pass --force to run the standalone installer against this database anyway.'
+  )
+}
+
 export function validateInstallFlags(options: InstallOptions): string | null {
   if (options.migration && options.direct) {
     return '`--migration` and `--direct` are mutually exclusive. Pick one.'
diff --git a/packages/cli/src/messages.ts b/packages/cli/src/messages.ts
index 9e671825..616b632c 100644
--- a/packages/cli/src/messages.ts
+++ b/packages/cli/src/messages.ts
@@ -59,6 +59,13 @@ export const messages = {
   },
   eql: {
     unknownSubcommand: 'Unknown eql subcommand',
+    /**
+     * Stable leader of the guard shown when `stash eql install` runs in a
+     * Prisma Next project — Prisma Next owns EQL installation via its own
+     * migration system, so the standalone installer is the wrong tool. The
+     * actionable command + `--force` note are appended at the call site.
+     */
+    prismaNextDetected: 'This looks like a Prisma Next project',
   },
   db: {
     unknownSubcommand: 'Unknown db subcommand',
diff --git a/packages/cli/tests/e2e/eql-install-prisma-next.e2e.test.ts b/packages/cli/tests/e2e/eql-install-prisma-next.e2e.test.ts
new file mode 100644
index 00000000..457eeb67
--- /dev/null
+++ b/packages/cli/tests/e2e/eql-install-prisma-next.e2e.test.ts
@@ -0,0 +1,35 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { messages } from '../../src/messages.js'
+import { runPiped } from '../helpers/spawn-piped.js'
+
+/**
+ * `stash eql install` must refuse in a Prisma Next project (Prisma Next owns
+ * EQL installation via its own migration ledger). The guard fires before any
+ * database I/O, so this needs no DB — and proves the wiring end-to-end (the
+ * pure guard is unit-tested separately).
+ */
+describe('stash eql install — Prisma Next guard', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'eql-install-pn-e2e-'))
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it('refuses with actionable guidance and exits 1 (no DB needed)', async () => {
+    writeFileSync(join(dir, 'prisma-next.config.ts'), 'export default {}')
+
+    const r = await runPiped(['eql', 'install'], { cwd: dir, timeoutMs: 15000 })
+
+    expect(r.timedOut).toBe(false)
+    expect(r.exitCode).toBe(1)
+    const out = r.stdout + r.stderr
+    expect(out).toContain(messages.eql.prismaNextDetected)
+    expect(out).toContain('prisma-next migration apply')
+    expect(out).toContain('--force')
+  })
+})
diff --git a/skills/stash-prisma-next/SKILL.md b/skills/stash-prisma-next/SKILL.md
index 6a4fa83e..2a03ef30 100644
--- a/skills/stash-prisma-next/SKILL.md
+++ b/skills/stash-prisma-next/SKILL.md
@@ -128,7 +128,9 @@ npx prisma-next migration apply      # installs EQL bundle + your schema
 
 Do **not** run `stash eql install` for a Prisma Next project — `prisma-next
 migration apply` owns EQL installation, and `stash init --prisma-next` skips the
-standalone installer for exactly this reason.
+standalone installer for exactly this reason. The CLI enforces this: `stash eql
+install` detects a Prisma Next project and refuses (pointing you at `prisma-next
+migration apply`) unless you pass `--force`.
 
 ## Writing and reading encrypted values